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

Question

Je veux ajouter un int dans un tableau, mais le problème est que je ne sais pas quel est l'indice actuel.

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 à quel index je l'assigne, mais que faire si je ne connais pas l'index...

En PHP, je peux simplement faire arr[]=22; qui ajoutera automatiquement 22 à l'indice vide suivant du tableau. Mais en C++, je ne peux pas faire cela, cela me donne une erreur de compilation. Que suggérez-vous ?

Answer 1

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

Vous pouvez utiliser un vector de cette façon :

#include <vector>

std::vector< int > arr;

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

Answer 2

En C++, les tableaux ne peuvent pas changer de taille en cours d'exécution. 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 l'en-tête et std espace de noms. Pour l'utiliser, vous devez :

#include <vector>

et aussi, soit utiliser std::vector dans votre code ou ajoutez

using std::vector; 

ou

using namespace std;

après le #include <vector> ligne.

Answer 3

Vous n'êtes pas obligé d'utiliser des vecteurs. Si vous voulez vous en tenir aux tableaux ordinaires, 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.
}

Il n'est pas aussi court et gracieux que l'équivalent PHP, mais il accomplit ce que vous vouliez faire. Pour vous permettre de modifier facilement la taille du tableau à l'avenir, 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 facilite grandement la gestion de la matrice à l'avenir. En remplaçant 15 par 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 prévue, car vous ne pourrez pas la modifier une fois le programme compilé. Par exemple, si vous avez un tableau de taille 100, vous ne pourrez jamais insérer 101 éléments.

Si vous devez utiliser des éléments à la fin du tableau, vous pouvez le faire :

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

Si vous voulez pouvoir supprimer des éléments dès le début (c'est-à-dire un FIFO), la solution devient plus compliquée. 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 modulo (%) pour faire en sorte que les index soient enveloppés. Par exemple, (99 + 1) % 100 est égal à 0 (un incrément d'enveloppement). Et (99 + 99) % 100 est 98 (une décrémentation de l'enveloppe). Cela vous permet d'éviter les instructions if et de rendre le code plus efficace.

Vous pouvez également constater rapidement l'utilité du #define lorsque votre code devient plus complexe. Malheureusement, même avec cette solution, vous ne pourrez jamais insérer plus de 100 éléments (ou le maximum que vous avez fixé) 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é les vecteurs. Un vecteur est géré en coulisses et de la nouvelle mémoire est allouée lorsque la structure s'étend. Il n'est toujours pas aussi efficace qu'un tableau dans les 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 existe des compromis pour chaque approche et il est préférable de connaître les deux.

Answer 4

Utilisez un vecteur :

#include <vector>

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

Answer 5

int arr[] = new int[15];

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

En php, je peux simplement faire ceci arr[]=22 ; cela ajoutera automatiquement 22 au prochain prochain index vide du tableau.

Le concept de "suivant" n'existe pas dans les tableaux.
Une chose importante que je pense que vous oubliez 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. Vous ne remplissez donc pas les éléments du tableau au fur et à mesure, ils sont déjà remplis, mais avec des valeurs non initialisées. Il n'y a aucun moyen de tester la présence d'un élément non initialisé dans un tableau.

Il semble que vous vouliez utiliser une structure de données telle qu'une file d'attente ou pile ou vecteur .