Hoe voeg ik een element toe aan een C++-array?

Ik wil een int toevoegen aan een array, maar het probleem is dat ik nu niet weet wat de index is.

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

Die code werkt omdat ik weet aan welke index ik toewijs, maar wat als ik de index niet ken…

In PHP kan ik gewoon arr[]=22;doen, wat automatisch 22 toevoegt aan de volgende lege index van de array. Maar in C++ kan ik dat niet doen, het geeft me een compilerfout. Wat raden jullie aan?

Antwoord 1, autoriteit 100%

Er is geen manier om te doen wat je zegt in C++ met gewone arrays. De C++-oplossing daarvoor is door de STL-bibliotheek te gebruiken die u de std::vector.

Je kunt een vectorop deze manier gebruiken:

#include <vector>
std::vector< int > arr;
arr.push_back(1);
arr.push_back(2);
arr.push_back(3);

Antwoord 2, autoriteit 74%

Arrays in C++ kunnen tijdens runtime niet van grootte veranderen. Voor dat doel moet u in plaats daarvan vector<int>gebruiken.

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.

Zoals vermeld in de opmerkingen, wordt vectorgedefinieerd in de vector-header en std-naamruimte. Om het te gebruiken, moet je:

#include <vector>

en gebruik ook std::vectorin uw code of voeg

toe

using std::vector; 

of

using namespace std;

na de regel #include <vector>.

Antwoord 3, autoriteit 19%

Je hoeft geen vectoren te gebruiken. Als je het bij gewone arrays wilt houden, kun je zoiets als dit doen:

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

Als u nu een element aan het einde van de array wilt toevoegen, kunt u dit doen:

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

Het is niet zo kort en sierlijk als het PHP-equivalent, maar het volbrengt wat je probeerde te doen. Om u in staat te stellen de grootte van de array in de toekomst gemakkelijk te wijzigen, kunt u een #define gebruiken.

#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.
}

Dit maakt het veel gemakkelijker om de array in de toekomst te beheren. Door 15 in 100 te veranderen, wordt de arraygrootte in het hele programma correct gewijzigd. Houd er rekening mee dat u de array op de maximaal verwachte grootte moet instellen, omdat u deze niet kunt wijzigen nadat het programma is gecompileerd. Als u bijvoorbeeld een array van grootte 100 heeft, kunt u nooit 101 elementen invoegen.

Als u elementen aan het einde van de array gaat gebruiken, kunt u dit doen:

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

Als u elementen vanaf het begin wilt kunnen verwijderen (dwz een FIFO), wordt de oplossing ingewikkelder. Je hebt ook een begin- en eindindex nodig.

#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.
}

Hier gebruiken we de modulus-operator (%) om ervoor te zorgen dat de indexen teruglopen. Bijvoorbeeld, (99 + 1) % 100 is 0 (een wikkeltoename). En (99 + 99) % 100 is 98 (een wikkelvermindering). Hierdoor kunt u if-statements vermijden en de code efficiënter maken.

Je kunt ook snel zien hoe nuttig de #define is naarmate je code complexer wordt. Helaas kunt u zelfs met deze oplossing nooit meer dan 100 items (of welk maximum u ook instelt) in de array invoegen. U gebruikt ook 100 bytes geheugen, zelfs als er maar 1 item in de array is opgeslagen.

Dit is de belangrijkste reden waarom anderen vectoren hebben aanbevolen. Achter de schermen wordt een vector beheerd en naarmate de structuur groter wordt, wordt nieuw geheugen toegewezen. Het is nog steeds niet zo efficiënt als een array in situaties waarin de gegevensomvang al bekend is, maar voor de meeste doeleinden zullen de prestatieverschillen niet belangrijk zijn. Er zijn compromissen voor elke benadering en het is het beste om beide te kennen.

Antwoord 4, autoriteit 13%

Gebruik een vector:

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

Antwoord 5, autoriteit 13%

int arr[] = new int[15];

De variabele arrbevat een geheugenadres. Op het geheugenadres staan 15 opeenvolgende ints achter elkaar. Er kan naar worden verwezen met index 0 tot en met 14.

In php kan ik dit gewoon doen arr[]=22;
dit voegt automatisch 22 toe aan de
volgende lege index van array.

Er is geen concept van ‘volgende’ bij het omgaan met arrays.
Een belangrijk ding dat ik denk dat je mist, is dat zodra de array is gemaakt, alle elementen van de array al bestaan. Ze zijn niet geïnitialiseerd, maar ze bestaan allemaal al. U ‘vult’ dus niet de elementen van de array terwijl u bezig bent, ze zijn al gevuld, alleen met niet-geïnitialiseerde waarden. Er is geen manier om te testen op een niet-geïnitialiseerd element in een array.

Het klinkt alsof je een gegevensstructuur wilt gebruiken, zoals een wachtrijof stapelenof vector.

Antwoord 6, autoriteit 6%

Ik ben het volledig eens met de vectormanier bij het implementeren van een dynamische array. Houd er echter rekening mee dat STL u een groot aantal containers biedt die voldoen aan verschillende runtime-vereisten. Kies er een met zorg. Bv: Voor snel invoegen aan de achterkant heb je de keuze tussen een vectoren een deque.

En ik was het bijna vergeten, met grote kracht komt grote verantwoordelijkheid 🙂 Aangezien vector‘s flexibel in grootte zijn, worden ze vaak automatisch opnieuw toegewezen om aan te passen voor het toevoegen van elementen. Pas dus op voor ongeldige iterator (ja, het geldt ook voor wijzers). Zolang u echter operator[]gebruikt voor toegang tot de afzonderlijke elementen, bent u veilig.

Antwoord 7, autoriteit 3%

Misschien mis ik het punt van uw vraag hier, en als dat zo is, bied ik mijn excuses aan. Maar als u geen items verwijdert, maar ze toevoegt, waarom wijst u dan niet gewoon een variabele toe aan de volgende lege ruimte? Telkens wanneer u een nieuwe waarde aan de array toevoegt, verhoogt u de waarde zodat deze naar de volgende wijst.

In C++ is een betere oplossing om het standaard bibliotheektype std::list< type >, waarmee de array ook dynamisch kan groeien, bijvoorbeeld:

#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);

Antwoord 8, autoriteit 2%

Initialiseer eerst al uw array-elementen op null en zoek vervolgens naar de null om het lege slot te vinden

Antwoord 9, autoriteit 2%

Je kunt een variabele gebruiken om plaatsen in de array te tellen, dus als je een nieuw element toevoegt, plaats je het op de juiste plaats. Bijvoorbeeld:

int a = 0;
int arr[5] = { };
arr[a] = 6;
a++;

Antwoord 10

Als u in C++ schrijft – is het een manier beter om gegevensstructuren te gebruiken van standaardbibliotheek zoals Vector.

C-Style-arrays zijn erg foutgevoelig en moeten waar mogelijk worden vermeden.

Antwoord 11

int array arraySize = 25;   
int array[arraySize];
array[0] = 3;
array[1] = 9;
array[2] = 27;

Als u de arrysize als 25 hebt gedefinieerd, kunt u niet meer waarden toevoegen dan 25.

Antwoord 12

Sinds ik zoveel negatieve feedback kreeg, besefte ik dat mijn oplossing verkeerd was, dus ik heb het veranderd.

int arr[20] = {1,2,3,4,5};
int index = 5;
void push(int n){
    arr[index] = n;
    index++;
}
push(6)

Nieuwe array bevat waarde van 1 tot 6 en u kunt ook functie maken voor verwijdering zoals deze.