Comment ajouter un élément au tableau C++?

Question

Je veux ajouter un int dans un tableau, mais le problème est que je ne sais pas ce que l'index est maintenant.

int[] arr = new int[15]; 
arr[0] = 1; 
arr[1] = 2; 
arr[2] = 3; 
arr[3] = 4; 
arr[4] = 5; 

Ce code fonctionne parce que je sais ce que je index assignant à, mais si je ne sais pas l'index ...

En PHP, je peux juste faire arr[]=22;, qui ajoutera automatiquement 22 à l'index vide suivant du tableau. Mais en C++ je ne peux pas faire ça, ça me donne une erreur de compilateur. que proposez-vous les gars? Les tableaux en C++ ne peuvent pas changer de taille lors de l'exécution.

Answer 1

Il n'y a aucun moyen de faire ce que vous dites en C++ avec des tableaux simples. La solution C++ pour cela est en utilisant la bibliothèque STL qui vous donne le std::vector.

Vous pouvez utiliser un vector de cette façon:

std::vector<int> arr; 

arr.push_back(1); 
arr.push_back(2); 
arr.push_back(3); 

Answer 2

Pour cela, vous devez utiliser vector<int> à la place.

vector<int> arr; 
arr.push_back(1); 
arr.push_back(2); 

// arr.size() will be the number of elements in the vector at the moment. 

Comme mentionné dans les commentaires, vector est défini dans vector-tête et std espace de noms. Pour l'utiliser, vous devez:

#include <vector>

et aussi, utilisez std::vector dans votre code ou ajouter

using std::vector; 

ou

using namespace std; 

après la ligne #include <vector>.

Answer 3

Utilisez un vecteur:

#include <vector> 

void foo() { 
    std::vector <int> v; 
    v.push_back(1);  // equivalent to v[0] = 1 
} 

Answer 4

int arr[] = new int[15]; 

La arr variable contient une adresse mémoire. À l'adresse mémoire, il y a 15 ints consécutifs dans une rangée. Ils peuvent être référencés avec l'index 0 à 14 inclus.

En php je peux juste faire ceci arr [] = 22; cela ajoutera automatiquement 22 à l'index suivant de tableau.

Il n'y a pas de notion de 'suivant' pour les tableaux.
Une chose importante que je pense que vous manquez est que dès que le tableau est créé, tous les éléments du tableau existent déjà. Ils ne sont pas initialisés, mais ils existent déjà tous. Donc, vous ne remplissez pas les éléments du tableau au fur et à mesure, ils sont déjà remplis, juste avec des valeurs non initialisées. Il n'y a aucun moyen de tester un élément non initialisé dans un tableau. Il semble que vous vouliez utiliser une structure de données telle que queue ou stack ou vector.

Answer 5

Je suis entièrement d'accord avec la méthode vector lors de l'implémentation d'un tableau dynamique.Cependant, gardez à l'esprit que STL vous fournit une multitude de conteneurs qui répondent à différentes exigences d'exécution. Vous devez en choisir un avec soin. E.g: Pour une insertion rapide à l'arrière, vous avez le choix entre un vector et un deque. J'ai presque oublié, avec une grande puissance vient une grande responsabilité :-) Depuis vector s sont flexibles en taille, ils se réallouent souvent automagically pour ajuster pour ajouter des éléments.Pour se méfier de l'invalidation itérateur (oui, il s'applique aussi aux pointeurs). Cependant, tant que vous utilisez operator[] pour accéder aux éléments individuels, vous êtes en sécurité.

Answer 6

Je peux manquer le point de votre question ici, et si oui, je m'excuse. Mais, si vous ne supprimez pas d'éléments en les ajoutant, pourquoi ne pas simplement assigner une variable à l'emplacement vide suivant? Chaque fois que vous ajoutez une nouvelle valeur au tableau, incrémentez simplement la valeur pour qu'elle pointe vers la suivante.

En C++ une meilleure solution est d'utiliser le type de bibliothèque standard std::list<type>, ce qui permet également le tableau de croître de façon dynamique, par exemple:

#include <list> 

std::list<int> arr; 

for (int i = 0; i < 10; i++) 
{ 
    // add new value from 0 to 9 to next slot 
    arr.push_back(i); 
} 

// add arbitrary value to the next free slot 
arr.push_back(22); 

Answer 7

Si vous écrivez en C++ - il est un moyen mieux utiliser des structures de données à partir d'une bibliothèque standard telle qu'un vecteur.

Les tableaux de type C sont très sujets aux erreurs et doivent être évités autant que possible.

Answer 8

Initialise tous vos éléments de tableau à zéro d'abord, puis recherchez le null pour trouver l'emplacement vide

Answer 9

Vous ne devez pas utiliser des vecteurs. Si vous voulez coller avec des tableaux simples, vous pouvez faire quelque chose comme ceci:

int arr[] = new int[15]; 
unsigned int arr_length = 0; 

Maintenant, si vous voulez ajouter un élément à la fin du tableau, vous pouvez le faire:

if (arr_length < 15) { 
    arr[arr_length++] = <number>; 
} else { 
    // Handle a full array. 
} 

Ce n'est pas aussi court et gracieux que l'équivalent PHP, mais il accomplit ce que vous essayiez de faire. Pour vous permettre de modifier facilement la taille du tableau dans le futur, vous pouvez utiliser un #define.

#define ARRAY_MAX 15 

int arr[] = new int[ARRAY_MAX]; 
unsigned int arr_length = 0; 

if (arr_length < ARRAY_MAX) { 
    arr[arr_length++] = <number>; 
} else { 
    // Handle a full array. 
} 

Cela simplifie grandement la gestion de la baie dans le futur. En changeant 15 à 100, la taille du tableau sera modifiée correctement dans l'ensemble du programme. Notez que vous devrez définir le tableau à la taille maximale attendue, car vous ne pouvez pas le modifier une fois le programme compilé. Par exemple, si vous avez un tableau de taille 100, vous ne pouvez jamais insérer 101 éléments.

Si vous utilisez des éléments hors la fin du tableau, vous pouvez le faire:

if (arr_length > 0) { 
    int value = arr[arr_length--]; 
} else { 
    // Handle empty array. 
} 

Si vous voulez être en mesure de supprimer des éléments hors début, (soit une FIFO), la solution devient plus compliqué. Vous avez également besoin d'un index de début et de fin.

#define ARRAY_MAX 15 

int arr[] = new int[ARRAY_MAX]; 
unsigned int arr_length = 0; 
unsigned int arr_start = 0; 
unsigned int arr_end = 0; 

// Insert number at end. 
if (arr_length < ARRAY_MAX) { 
    arr[arr_end] = <number>; 
    arr_end = (arr_end + 1) % ARRAY_MAX; 
    arr_length ++; 
} else { 
    // Handle a full array. 
} 

// Read number from beginning. 
if (arr_length > 0) { 
    int value = arr[arr_start]; 
    arr_start = (arr_start + 1) % ARRAY_MAX; 
    arr_length --; 
} else { 
    // Handle an empty array. 
} 

// Read number from end. 
if (arr_length > 0) { 
    int value = arr[arr_end]; 
    arr_end = (arr_end + ARRAY_MAX - 1) % ARRAY_MAX; 
    arr_length --; 
} else { 
    // Handle an empty array. 
} 

Ici, nous utilisons l'opérateur de module (%) pour provoquer l'enroulement des index. Par exemple, (99 + 1)% 100 est 0 (un incrément d'enrobage). Et (99 + 99)% 100 est 98 (une diminution d'emballage). Cela vous permet d'éviter les instructions if et de rendre le code plus efficace.

Vous pouvez également voir rapidement à quel point le #define est utile lorsque votre code devient plus complexe.Malheureusement, même avec cette solution, vous ne pouvez jamais insérer plus de 100 éléments (ou tout autre maximum que vous avez défini) dans le tableau. Vous utilisez également 100 octets de mémoire même si un seul élément est stocké dans le tableau.

C'est la principale raison pour laquelle d'autres ont recommandé des vecteurs. Un vecteur est géré dans les coulisses et une nouvelle mémoire est allouée à mesure que la structure se développe. Il n'est toujours pas aussi efficace qu'un tableau dans des situations où la taille des données est déjà connue, mais dans la plupart des cas, les différences de performances ne seront pas importantes. Il y a des compromis à chaque approche et il est préférable de connaître les deux.