Define array, puis changez sa taille

Je viens d'une java d'arrière-plan et il y a quelque chose que je pouvais faire en Java que j'ai besoin de le faire en C++, mais je ne suis pas sûr de savoir comment faire.

J'ai besoin de déclarer un tableau, mais pour le moment je ne sais pas la taille. Une fois que je connais la taille, puis j'ai mis la taille du tableau. J'java, je voudrais juste faire quelque chose comme:

int [] array;

puis

array = new int[someSize];

Comment puis-je le faire en C++?

Avez-vous juste de ne pas connaître la taille ou connaissez-vous la taille seulement après avoir lu quelque chose au moment de l'exécution? I. e. est la taille de la compilation constante de temps? Il y a plus de moyens faciles pour résoudre ce que l'usage de la nouvelle ou de vecteurs dans ce cas.
Je vois d'ici la réponse que vous avez accepté que vous ne semblent pas penser std::vector va travailler pour vous. Pourquoi est-ce?

OriginalL'auteur user69514 | 2010-10-03

arrays c++

15

En C++, vous pouvez faire:
```
int *array; //declare a pointer of type int.
array = new int[someSize]; //dynamically allocate memory using new
```
et une fois que vous avez terminé d'utiliser la mémoire..de-allouer l'aide de la suppression:
```
delete[]array;
```
C'est exact, et perspicace, mais vraiment, on devrait encourager l'utilisation de std::vector en C++. C'est ce que le conteneur est là pour, et hormis les avantages évidents de conteneurs standard de bien jouer avec RAII et ainsi de suite, sous la peau std::vector a ce code il y a à l'intérieur de l'octet-par-octet. Habituellement, les raisons de ne pas utiliser des conteneurs standard avoir à faire avec la disponibilité des modèles, non-standard compilateur et ainsi de suite. Je ne vais pas upvote cette réponse n'est pas parce que c'est mal, mais parce qu'il cache beaucoup de choses importantes, les informations pertinentes que vous devez toujours conscients.
Il est très important que vous ne delete[] array; sinon, vous aurez une fuite de mémoire et c'est dangereux

OriginalL'auteur codaddict
27

vous souhaitez utiliser std::vector dans la plupart des cas.
```
std::vector<int> array;

array.resize(someSize);
```
Mais si vous insistez sur l'utilisation de new, alors vous devez faire pour un peu plus de travail que vous faites en Java.
```
int *array;
array = new int[someSize];

//then, later when you're done with array

delete [] array;
```
Pas de c++ runtime venir avec la collecte des ordures par défaut, de sorte que le delete[] est nécessaire pour éviter les fuites de mémoire. Vous pouvez obtenir le meilleur des deux mondes à l'aide d'un type pointeur intelligent, mais vraiment, il suffit d'utiliser std::vector.

Pfff. Il est surprenant de constater SOI-izens sont bien comportés, tout comme nous. +1.
C++ std::vector a beaucoup en commun avec Java java.util.ArrayList vraiment. (Il y a des différences, mais les similitudes sont fortes.)

OriginalL'auteur SingleNegationElimination
1

Meilleur moyen serait pour vous d'utiliser un std::vector. Il fait tout ce que vous voulez et est facile à utiliser et à apprendre. Aussi, puisque c'est le C++, vous devez utiliser un vector au lieu d'un tableau. Ici est une excellente raison pour expliquer pourquoi vous devriez utiliser une classe de conteneur (un vecteur) au lieu d'un tableau.

Vecteurs sont dynamiques dans la taille et à mesure que vous en avez besoin, tout ce que vous voulez.

OriginalL'auteur user225312
1

La réponse exacte:
```
char * array = new char[64]; //64-byte array

//New array
delete[] array;
array = new char[64];
```
std::vector est un bien meilleur choix dans la plupart des cas, cependant. Il le fait ce dont vous avez besoin sans le manuel de supprimer et de nouvelles commandes.

Je dirais tous les cas.
GMan: Sauf pour l'apprentissage de la théorie, je serais d'accord.

OriginalL'auteur ssube
1

Comme d'autres l'ont mentionné, std::vector est généralement la voie à suivre. La raison en est que le vecteur est très bien compris, c'est normalisée dans les compilateurs et les plates-formes, et surtout, il protège le programmeur de l'difficultés de gestion manuelle de la mémoire. En outre, les éléments du vecteur doivent être attribuées de manière séquentielle (c'est à dire, les éléments du vecteur A, B, C apparaîtra dans la mémoire continue dans le même ordre qu'ils ont été poussés dans le vecteur). Cela devrait rendre le vecteur de cache-friendly comme régulière d'un tableau alloué dynamiquement.

Alors que le même résultat pourrait certainement être accompli par la déclaration d'un pointeur de int et de la gestion manuelle de la mémoire, cela impliquerait un travail supplémentaire:
1. Chaque fois que vous avez besoin de plus de mémoire, vous devez allouer manuellement il
2. Vous devez être très prudent pour effacer toute la mémoire précédemment allouée avant d'assigner une nouvelle valeur à l'aide du pointeur, de peur que vous serez coincé avec d'énormes fuites de mémoire
3. Contrairement à std::vector, cette approche n'est pas RAIIde l'environnement. Considérons l'exemple suivant:
```
void function()
{
    int* array = new int[32];
    char* somethingElse = new char[10];
    //Do something useful.... No returns here, just one code path.
    delete[] array;
    delete[] somethingElse;
}
```
Il semble sain et sauf. Mais il n'est pas. Que faire si, lors de la tentative d'allouer 10 octets pour "somethingElse", le système manque de mémoire? Une exception de type std::bad_alloc sera levée, qui va commencer à dépiler la recherche d'un gestionnaire d'exception, sauter les instructions de suppression à la fin de la fonction. Vous avez une fuite de mémoire. C'est l'une des nombreuses raisons pour éviter de gestion manuelle de la mémoire en C++. Pour remédier à cela (si vous voulez vraiment, vraiment), le Boost bibliothèque fournit un tas de nice RAII wrappers, comme scoped_array et scoped_ptr.

OriginalL'auteur Martin Törnwall

utiliser std::array lorsque la taille est connue au moment de la compilation, sinon utiliser des std::vector

#include <array>
constexpr int someSize = 10;
std::array<int, someSize> array;

#include <vector>
std::vector<int> array;  //size = 0
array.resize(someSize);  //size = someSize

OriginalL'auteur SiegfriedDb

-1

Déclarer un pointeur:
```
int * array;
```
Ce n'est pas très utile sans tout à fait un peu de contexte.
Que serait (le début de) la réponse correcte en C, en C++, vous devez utiliser un pointeur si vous avez une solide raison pour ne pas utiliser std::vector ou std::deque.
Je suppose que le solide raison pour ne pas utiliser java.util.Vector serait de transférer et de devenir la solide raison pour ne pas utiliser std::vector. Et je tente une réponse simple maintenant. Nous allons voir comment il va.
pour ce commentaire. 🙂
la simple raison pour ne pas utiliser java.util.Vector serait la simple raison que c'est un C++ question. Java, C++ ce que les pissenlits sont des points-virgules.

OriginalL'auteur aib

Vous devez vous connecter pour publier un commentaire.