Comment ajouter un élément à un tableau C ++?
Je veux ajouter un int dans un tableau, mais le problème est que je ne sais pas quel est l'index.
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 j'attribue, mais si je ne connais pas l'index ...
En PHP, je peux juste faire arr[]=22;, qui ajoutera automatiquement 22 au prochain index vide du tableau. Mais en C++, je ne peux pas faire cela, cela me donne une erreur de compilation. que proposez-vous les gars?
Il n’ya aucun moyen de faire ce que vous dites en C++ avec des tableaux simples. La solution C++ consiste à utiliser 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);
Les tableaux en C++ ne peuvent pas changer de taille au moment de l'exécution. Pour cela, vous devez utiliser vector<int> au lieu.
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 en-tête et std espace de noms. Pour l'utiliser, vous devriez:
#include <vector>
et aussi, soit utiliser std::vector dans votre code ou ajouter
using std::vector;
ou
using namespace std;
après le #include <vector> ligne.
Utilisez un vecteur:
#include <vector>
void foo() {
std::vector <int> v;
v.Push_back( 1 ); // equivalent to v[0] = 1
}
int arr[] = new int[15];
La variable arr contient une adresse mémoire. À l'adresse mémoire, il y a 15 entrées consécutives consécutives. Ils peuvent être référencés avec les indices 0 à 14 inclus.
En php je peux juste faire ceci arr [] = 22; cela ajoutera automatiquement 22 au prochain index vide du tableau.
Il n'y a pas de concept de "suivant" lorsqu'il s'agit de tableaux.
Une chose importante que je pense que vous manquez, c'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 tous déjà. 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 souhaitiez utiliser une structure de données telle que file d'attente ou pile ou vecteur .
Vous n'êtes pas obligé d'utiliser des vecteurs. Si vous voulez rester 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 faire ceci:
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 tentiez de faire. Pour vous permettre de changer facilement la taille du tableau à l'avenir, vous pouvez utiliser un # définir.
#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 beaucoup la gestion du tableau à l'avenir. En modifiant 15 à 100, la taille de la matrice sera modifiée correctement dans tout le programme. Notez que vous devrez définir la taille du tableau sur la taille maximale attendue, car vous ne pourrez pas le 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 utilisez 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 au début (par exemple, une 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 de module (%) pour que les index soient renvoyés à la ligne. Par exemple, (99 + 1)% 100 est égal à 0 (un incrément d'habillage). Et (99 + 99)% 100 correspond à 98 (une décrémentation enveloppante). Cela vous permet d'éviter les déclarations 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 le maximum que vous définissez) 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 raison principale pour laquelle d'autres ont recommandé les vecteurs. Un vecteur est géré en arrière-plan 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 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 entre chaque approche et il est préférable de connaître les deux.
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 foule de conteneurs répondant à 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.
Et j'oubliais presque, avec beaucoup de puissance, de grandes responsabilités :-) Puisque vectors sont flexibles en taille, ils sont souvent réaffectés automatiquement pour permettre l'ajout d'éléments. ). Cependant, tant que vous utilisez operator[] pour accéder aux éléments individuels, vous êtes en sécurité.
Il se peut que je passe à côté de l’objet de votre question et, s’il en est ainsi, je vous présente mes excuses. Mais, si vous ne supprimez pas d’éléments qui ne font que les ajouter, pourquoi ne pas simplement affecter une variable au prochain emplacement vide? 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 consiste à utiliser le type de bibliothèque standard std::list< type >, qui permet également à la matrice de se développer dynamiquement, 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);
Initialisez d'abord tous les éléments de votre tableau sur null, puis recherchez le null pour trouver l'emplacement vide
Si vous écrivez en C++, il est préférable d’utiliser les structures de données de bibliothèques standard telles que vector.
Les tableaux de style C sont très sujets aux erreurs et doivent être évités autant que possible.
Vous pouvez utiliser une variable pour compter les emplacements dans le tableau. Ainsi, chaque fois que vous ajoutez un nouvel élément, vous le placez au bon endroit. Par exemple:
int a = 0;
int arr[5] = { };
arr[a] = 6;
a++;