pointeur pointeur C++ Méthodes

Question

J'ai deux questions:

1) Comment puis-je faire un tableau qui pointe vers des objets d'entiers?

int* myName[5]; // is this correct? 

2) Si je veux retourner un pointeur vers un tableau, qui pointe vers des objets (comme (1)) comment puis-je faire cela dans une méthode? à savoir) Je veux impliment la méthode:

int **getStuff() { 
// what goes here? 
return *(myName); // im pretty sure this is not correct 
} 

Merci pour l'aide!

Answer 1

Comment faire un tableau qui pointe vers des objets?

int * myName[5]; /* correct */ 

Si je veux retourner un pointeur vers un tableau , qui pointe vers des objets (comme (1)) comment puis-je faire cela dans une méthode?

Techniquement, vous écrivez cette fonction:

int * (* getStuff())[5] { 
    return &myName; 
} 

qui renvoie un pointeur sur ce tableau. Cependant, vous ne voulez pas faire ça. Vous vouliez revenir un pointeur vers le premier élément du tableau:

int ** getStuff() { 
    return myName; /* or return &myName[0]; */ 
} 

De cette façon, vous pouvez maintenant accéder à des éléments que vous voulez comme getStuff()[0] = &someInteger;

Answer 2

1) Correct - c'est un tableau de 5 pointeurs vers int s

2) Vous pouvez renvoyer un pointeur vers un tableau de pointeurs vers int s en retournant un pointeur vers le premier élément de ce tableau. Cela a deux niveaux d'indirection, donc vous avez besoin de deux astérisques. Vous pouvez également retourner le tableau normalement, car les tableaux se désintègrent automatiquement en pointeurs vers leurs premiers éléments.

int **getStuff() { 
    return myName;  // 1 
    return &myName[0]; // 2 
} 

Answer 3

int **myName; 

int **getStuff() { 
    int **array = new int*[5]; 

    for (int i = 0; i < 5; i++) 
    { 
    int key = i; 
    array[i] = &key; 
    } 

    return array; 
} 

Answer 4

Notez que votre code,

int* myName[5]; 

déclare un tableau contenant 5 valeurs, dont chacun est un "pointeur vers int", qui est ce que vous avez demandé.

Cependant, étant C++, c'est tout ce qu'il fait. En tant que scripteur Python, cela pourrait vous causer quelques surprises.

Il ne donne aucune de ces 5 valeurs sensitives aux pointeurs, et il ne crée aucun entier pour qu'elles pointent vers.

Si vous le placez dans un corps de fonction, il crée le tableau sur la pile. Cela signifie que le tableau cessera d'exister lorsque la portée actuelle se terminera (ce qui, pour le dire simplement, signifie quand vous arrivez à l'entourage bouclé, donc par exemple le fait).Ainsi, en particulier, le code suivant est mauvais:

int **myFunction() { 
    int *myArray[5]; 
    return myArray; 
} // <-- end of scope, and return takes us out of it 

Il peut compiler, mais la fonction renvoie un pointeur sur quelque chose qui n'existe plus au moment où l'appelant voit. Cela conduit à ce que nous appelons un "comportement indéfini".

Si vous voulez que le tableau d'exister en dehors de la fonction, il est créé, vous pouvez en créer un sur le tas chaque fois que votre fonction est appelée et renvoie un pointeur, comme ceci:

int **myFunction() { 
    int **myArray = new int[5]; 
    return myArray; 
} 

La fonction retourne un tableau différent chaque fois qu'il est appelé. Lorsque l'appelant a terminé avec lui, il doit détruire le tableau, comme ceci:

delete[] myArray; 

sinon il ne sera jamais libéré, et siégera autour de l'utilisation de la mémoire pour toujours (ou lorsque votre programme se termine sur la plupart des systèmes d'exploitation). Alternativement, vous pouvez utiliser le mot-clé "static" pour créer un tableau avec "durée de stockage globale" (ce qui signifie qu'il existe tant que le programme est en cours d'exécution, mais il n'y en a qu'un seul à chaque fois). Cela signifie que la fonction renvoie le même tableau chaque fois qu'il est appelé. L'appelant peut stocker des pointeurs en elle, l'oublier, appelez à nouveau la fonction, et de voir les mêmes pointeurs toujours là:

int **myFunction() { 
    static int *myArray[5]; 
    return myArray; 
} 

Notez comment ce code est similaire au code très mauvais du début.

Enfin, si vous voulez juste créer un tableau de nombres entiers, pas un tableau de pointeurs vers des entiers, vous pouvez le faire:

int myArray[5] = { 1, 2, 3, 4, 5}; 

qui crée en fait 5 entiers (ce qui signifie, il assigne qui peut stocker les valeurs entières elles-mêmes, ce qui est différent du tableau de pointeurs, qui stocke les adresses de l'espace utilisé pour stocker les valeurs entières).

Il stocke également les valeurs spécifiées dans cet espace: myArray [0] est maintenant 1, myArray [1] est 2, etc.

Answer 5

Steve Jessop, je pense que vous vouliez dire:

int **myFunction() { 
    int **myArray = new int*[5]; 
    return myArray; 
} 

Answer 6

Cela retourne un pointeur de tableau de tas (pas de pointeur vers ses éléments), testable et effaçable. Rien ne fuit.

template <class T> 
T* newarray(int len) 
    { 
     T *a; 
     try 
      { 
       a = new T[len]; 
       memset(a,0,len*sizeof(T)); 
       return a; 
      } 
     catch (...)   
      {return 0;} 
    } 

. . .

void foo() 
    { 
     float *f=0; 
     f=newarray<float>(1000000); 
     if(!f) return; 
     //use f 
     delete [] f; 
    }