[c++]Besoins d'aide sur un pointer de pointer

Mr. Mime -  
 loupius -
Bonjour,
J'ai un petit problème lorsque je veux allouer de la mémoire dynamiquement.
Le pointeur de l'adresse du tableau à créer est dans mon main, et j'aimerais q'une fonction de type void
prenne se pointeur et alloue le tableau à l'intérieur.
Cependant, rien n'y fait, je crois que j'ai vraiment pas la bonne syntaxe...
Si j'ai poster avec comme titre pointeur de pointeur, c'est que j'ai bien l'impression que je vais devoir passer par là!

Le code est du style :

void allouer(int taille, int *pointeur)
{
*pointeur = new int[taille];
}

int main()
{
int* tableau = NULL;
allouer(25,tableau);
}
Configuration: Windows XP
Firefox 3.0.5

2 réponses

  1. loupius
     
    Oui, on peut utiliser un pointeur de pointeur, mais le plus simple:
    int* allouer (int taille)
    {
      return (new int[taille]);
    }
    
    int main()
    {
      int* tableau = allouer (25);
      ...
      delete tableau;
      return 0;
    }
    Toutefois il serait plus sain et plus simple d'écrire:
    int main()
    {
      int* tableau = new int[25];
      ...
      delete tableau;
      return 0;
    }
    0
    1. Sora Oseka
       
      ou si tu veut continuer dans ta peripetie :

      void allouer(int taille, int *pointeur)
      {
      *pointeur = new int[taille];
      }

      deviens

      void allouer(int **pointeur) // pour un pointer simple
      {
      *pointeur = new int; // donc pas de tableau
      }

      enfin la tu creer un tableau dont cela ne marchera pas, il te faudras une etoile en plus

      void allouer(int taille, int ***pointeur)
      {
      *pointeur = new int[taille];
      }
      0
      1. loupius > Sora Oseka
         
        Le pointeur 3 étoiles, c'est rigolo, mais je ne suis pas sûr que ce soit efficace ;=)
        0
      2. Mr. Mime > Sora Oseka
         
        Pourquoi je peux pas allouer un espace memoire tableau dans la fonction allouer....? O_o...***
        0
      3. loupius > Mr. Mime
         
        Je ne vois pas la difficulté d'allouer de l'espace qui sera considéré comme un tableau (Lorsque l'on déclare 'int* p = new int', on peut considérer déclarer un tableau d'un seul élément de type 'int') .
        void allouer (int taille, int **pointeur)
        {
        	*pointeur = new int[taille];  // L'idéal serait de faire un test sur 'taille'
        }
        
        int main (int argc, char **argv)
        {
        	int* tableau;
        	allouer (25, &tableau);  // Il faudrait vérifier que tableau n'est pas NULL
        	...
        	delete tableau;
        	return 0;
        }
        0
  2. fiddy Messages postés 441 Date d'inscription   Statut Contributeur Dernière intervention   1 847
     
    Salut,
    Oui, il faut passer par un double pointeur si tu veux l'allouer dans une fonction de type void.
    Ce qui donne :
    void allouer(const int taille, int **pointeur)
    {
    *pointeur = new int[taille];
    }
    
    int main(void)
    {
    int* tableau = NULL;
    allouer(25,&tableau);
    delete tableau;
    
    return 0;
    }
    

    Cdlt
    0