Come aggiungere un elemento all'array C++?

Question

Voglio aggiungere un int a un array, ma il problema è che non so quale sia l'indice adesso.

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

Questo codice funziona perché so quello dell'indice Sto assegnando a, ma cosa succede se non so l'indice ...

In PHP, posso solo fare arr[]=22;, che si aggiungerà automaticamente 22 al successivo indice vuoto dell'array. Ma in C++ non posso farlo, mi dà un errore del compilatore. Cosa suggerite voi ragazzi?

Answer 1

Non v'è alcun modo per fare quello che dici in C++ con gli array semplici. La soluzione C++ per questo è utilizzando la libreria STL che ti dà il std::vector.

È possibile utilizzare un vector in questo modo:

std::vector<int> arr; 

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

Answer 2

Le matrici in C++ non possono cambiare dimensione in fase di esecuzione. A tale scopo, è necessario utilizzare vector<int>.

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. 

Come accennato nei commenti, vector è definito in vector intestazione e std namespace. Per utilizzarlo, è necessario:

#include <vector>

e anche, utilizzare std::vector nel codice o aggiungere

using std::vector; 

o

using namespace std; 

dopo la linea #include <vector>.

Answer 3

Utilizzare un vettore:

#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 variabile arr tiene un indirizzo di memoria. All'indirizzo di memoria ci sono 15 interi consecutivi di fila. Possono essere referenziati con l'indice da 0 a 14 incluso.

In php posso solo fare questo arr [] = 22; questo aggiungerà automaticamente 22 al successivo indice di array vuoto .

Non esiste il concetto di "prossimo" quando si tratta di matrici.
Una cosa importante che penso manchi è che non appena viene creato l'array, esistono già tutti gli elementi dell'array. Non sono inizializzati, ma tutti esistono già. Quindi non stai "riempiendo" gli elementi dell'array mentre vai, sono già pieni, solo con valori non inizializzati. Non c'è modo di testare un elemento non inizializzato in un array.

Sembra che si desideri utilizzare una struttura dati come queue o stack o vector.

Answer 5

Concordo pienamente con il modo vector quando si implementa un array dinamico.Tuttavia, tieni presente che STL ti offre una serie di contenitori che soddisfano diversi requisiti di runtime. Dovresti sceglierne uno con cura. Ad esempio: per l'inserimento rapido sul retro è possibile scegliere tra uno vector e uno deque.

E quasi dimenticavo, con grande potenza derivano grandi responsabilità :-) Poiché vector s sono di dimensioni flessibili, spesso si riallocano automagicamente per adattarsi all'aggiunta di elementi. Prestare attenzione all'invalidazione dell'iteratore (sì, si applica anche ai puntatori). Tuttavia, finché usi operator[] per accedere ai singoli elementi sei al sicuro.

Answer 6

Potrei mancare il punto della tua domanda qui, e se è così mi scuso. Ma, se non stai cancellando alcun elemento aggiungendoli solo, perché non assegnare semplicemente una variabile allo slot vuoto successivo? Ogni volta che aggiungi un nuovo valore alla matrice, basta incrementare il valore per puntare a quello successivo.

In C++ una soluzione migliore è quella di utilizzare il tipo di libreria standard std::list<type>, che permette anche la matrice di crescere in modo dinamico, ad esempio:

#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

Se si scrive in C++ - è un modo migliore per utilizzare le strutture dati dalla libreria standard come il vettore.

Gli array in stile C sono molto suscettibili agli errori e dovrebbero essere evitati quando possibile.

Answer 8

inizializzare tutti gli elementi dell'array è null, poi cercare il nulla per trovare la slot vuoto

Answer 9

Non è necessario usare vettori. Se si vuole attaccare con gli array semplici, si può fare qualcosa di simile:

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

Ora, se si desidera aggiungere un elemento alla fine dell'array, si può fare questo:

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

Non è il più breve e grazioso dell'equivalente PHP, ma realizza ciò che stavi tentando di fare. Per consentire di modificare facilmente la dimensione della matrice in futuro, è possibile utilizzare 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. 
} 

Ciò rende molto più semplice la gestione dell'array in futuro. Cambiando da 15 a 100, la dimensione dell'array verrà cambiata correttamente nell'intero programma. Si noti che sarà necessario impostare la matrice sulla dimensione massima prevista, in quanto non è possibile modificarla una volta che il programma è stato compilato. Ad esempio, se si dispone di un array di dimensioni 100, non è mai possibile inserire 101 elementi.

Se si prevede di utilizzare gli elementi fuori la fine dell'array, si può fare questo:

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

Se si vuole essere in grado di eliminare gli elementi fuori l'inizio, (vale a dire un FIFO), la soluzione diventa più complicato. Hai bisogno anche di un indice di inizio e fine.

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

Qui, stiamo utilizzando l'operatore modulo (%) per causare l'inclusione degli indici. Ad esempio, (99 + 1)% 100 è 0 (un incremento di avvolgimento). E (99 + 99)% 100 è 98 (un decremento di avvolgimento). Questo ti permette di evitare dichiarazioni if ​​e rendere il codice più efficiente.

È anche possibile vedere quanto è utile il #define quando il codice diventa più complesso.Sfortunatamente, anche con questa soluzione, non è mai possibile inserire oltre 100 elementi (o qualsiasi altro valore massimo impostato) nell'array. Si stanno anche utilizzando 100 byte di memoria anche se nella matrice è presente solo 1 elemento.

Questo è il motivo principale per cui altri hanno consigliato i vettori. Un vettore è gestito dietro le quinte e la nuova memoria viene allocata man mano che la struttura si espande. Non è ancora efficiente come una matrice in situazioni in cui la dimensione dei dati è già nota, ma per la maggior parte dei casi le differenze di prestazioni non saranno importanti. Ci sono dei compromessi per ciascun approccio ed è meglio sapere entrambi.