Je souhaite initialiser un tableau, puis initialiser un pointeur sur ce tableau.Initialisation d'un tableau avant l'initialisation d'un pointeur sur ce même tableau
int *pointer;
pointer = new int[4] = {3,4,2,6};
delete[] pointer;
pointer = new int[4] = {2,7,3,8};
delete[] pointer;
Comment est-ce que je peux faire ceci?
Pourquoi ne pas utiliser
int array[4] = {3, 4, 2, 6};
Y at-il une raison que vous voulez allouer de la mémoire pour le tableau de tas?
Suggestion après commentaire:
int arrays[32][4] = {{3, 4, 2, 6}, {3, 4, 1, 2}, ...}
int *pointers[4];
pointers[0] = arrays[0];
pointers[1] = arrays[12];
pointers[2] = arrays[25];
pointers[3] = arrays[13];
...
pointers[0] = arrays[13];
pointers[1] = arrays[11];
pointers[2] = arrays[21];
pointers[3] = arrays[6];
Eh bien, j'écris une fonction qui aura 32 tableaux, essentiellement les mêmes 4 tableaux mais avec des membres différents. Je voulais en quelque sorte le garder à 4 tableaux et les ré-initialiser à 8 points différents dans la fonction. – Alex
Vous pouvez simplement réutiliser ces quatre tableaux en les écrasant avec les nouveaux numéros nécessaires. – sbi
Que voulez-vous dire par "les écraser"? – Alex
int *pointer = new int[4]{3,4,2,6};
EDIT: Comme indiqué dans les commentaires, c'est C++ 0x syntaxe. Pour ce faire dans les versions antérieures, écrivez une fonction qui prend un tableau de pile + taille, alloue un nouveau tableau sur le tas, boucle sur le tableau de pile en remplissant le tableau de tas, puis retourne un pointeur vers le tableau de tas.
int* foo(const int size, int *array)
{
int *newArray = new int[size];
for(int index = 0; index < size; ++index)
{
newArray[index] = array[index];
}
return newArray;
}
L'appel ressemblerait à ceci:
int a[] = { 1, 2, 3, 4 };
int *ptr = foo(4, a);
Il prend deux lignes, mais au moins est plus facile que l'initialisation ligne par ligne.
Ceci est la syntaxe C++ 0x. –
Cela ne semble pas fonctionner pour moi sur le compilateur g ++. – Alex
Ouais, mon mauvais. Je pensais que cela fonctionnerait pré-C++ 0x. –
//initialize the array
int array[] = {3,4,2,6};
// initialize a pointer to that array
int *pointer = array;
Le problème avec cette approche est que le pointeur * peut UNIQUEMENT être utilisé dans cette portée car il pointe vers une variable de pile qui sera retirée de la pile une fois que la portée sera terminée. –
S'assurer que votre pointeur pointe vers des données valides avant de l'utiliser est un peu évident, n'est-ce pas? On peut certainement avoir un pointeur sur l'un des 'mêmes 4 tableaux mais avec des membres différents' (comme Alex a besoin). –
Comme d'autres l'ont souligné, vous pouvez initialiser des tableaux non tas, par exemple:
static const int ar1[4] = { ... };
static const int ar2[4] = { ... };
initialize Ensuite, votre tableau alloué dynamiquement à partir des données statiques:
void func()
{
int *pointer = new int[4];
...
memcpy(pointer, ar1, sizeof(ar1));
...
memcpy(pointer, ar2, sizeof(ar2));
...
Vous pouvez faire quelque chose comme ça avec un conteneur standard et boost :: assign.
std::vector vect = list_of(3)(4)(2)(6);
...
vect = list_of(2)(7)(3)(8);
Est-ce que cela fait partie des exigences? Vous ne l'avez pas mentionné dans votre question. –
Eh bien, je veux juste un moyen que je peux mettre à jour le même pointeur vers de nouveaux tableaux, mais les tableaux doivent être initialisés. Donc, je pense que cela doit être fait sur le tas, mais de toute façon cela fonctionne me rendra heureux. – Alex
Quelle est la plus grande image ici? – GManNickG