¿Cómo agregar un elemento a la matriz de C++?

Quiero agregar un int a una matriz, pero el problema es que ahora no sé cuál es el índice.

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

Ese código funciona porque sé a qué índice estoy asignando, pero qué pasa si no sé el índice…

En PHP, solo puedo hacer arr[]=22;, que agregará automáticamente 22 al siguiente índice vacío de la matriz. Pero en C++ no puedo hacer eso, me da un error de compilación. ¿Qué sugieren ustedes, chicos?

No hay forma de hacer lo que dices en C++ con matrices simples. La solución de C++ para eso es usar la biblioteca STL que le brinda la std::vector.

Puedes usar un vector De este modo:

#include <vector>

std::vector< int > arr;

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

Las matrices en C++ no pueden cambiar de tamaño en tiempo de ejecución. Para ello, debe utilizar vector<int> en cambio.

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.

Como se menciona en los comentarios, vector se define en vector encabezado y std espacio de nombres Para usarlo, debes:

#include <vector>

y también, ya sea usar std::vector en tu código o agrega

using std::vector; 

o

using namespace std;

después de la #include <vector> línea.

No tienes que usar vectores. Si desea seguir con arreglos simples, puede hacer algo como esto:

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

Ahora, si desea agregar un elemento al final de la matriz, puede hacer esto:

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

No es tan corto y elegante como el equivalente de PHP, pero logra lo que intentabas hacer. Para permitirle cambiar fácilmente el tamaño de la matriz en el futuro, puede usar 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.
}

Esto hace que sea mucho más fácil administrar la matriz en el futuro. Al cambiar 15 a 100, el tamaño de la matriz cambiará correctamente en todo el programa. Tenga en cuenta que tendrá que configurar la matriz al tamaño máximo esperado, ya que no puede cambiarla una vez que se compila el programa. Por ejemplo, si tiene una matriz de tamaño 100, nunca podría insertar 101 elementos.

Si va a utilizar elementos fuera del final de la matriz, puede hacer esto:

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

Si desea poder eliminar elementos desde el principio (es decir, un FIFO), la solución se vuelve más complicada. También necesita un índice inicial y final.

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

Aquí, estamos usando el operador de módulo (%) para hacer que los índices se ajusten. Por ejemplo, (99 + 1) % 100 es 0 (un incremento envolvente). Y (99 + 99) % 100 es 98 (un decremento envolvente). Esto le permite evitar declaraciones if y hacer que el código sea más eficiente.

También puede ver rápidamente cuán útil es #define a medida que su código se vuelve más complejo. Desafortunadamente, incluso con esta solución, nunca podría insertar más de 100 elementos (o el máximo que establezca) en la matriz. También está utilizando 100 bytes de memoria incluso si solo se almacena 1 elemento en la matriz.

Esta es la razón principal por la que otros han recomendado vectores. Un vector se administra entre bastidores y se asigna nueva memoria a medida que se expande la estructura. Todavía no es tan eficiente como una matriz en situaciones en las que ya se conoce el tamaño de los datos, pero para la mayoría de los propósitos, las diferencias de rendimiento no serán importantes. Hay ventajas y desventajas para cada enfoque y es mejor conocer ambos.

Usa un vector:

#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 tiene una dirección de memoria. En la dirección de memoria, hay 15 enteros consecutivos en una fila. Se pueden referenciar con índice 0 a 14 inclusive.

En php solo puedo hacer esto arr[]=22; esto agregará automáticamente 22 al siguiente índice vacío de la matriz.

No existe el concepto de ‘siguiente’ cuando se trata de matrices.
Una cosa importante que creo que te estás perdiendo es que tan pronto como se crea la matriz, todos los elementos de la matriz ya existen. No están inicializados, pero ya existen. Por lo tanto, no está ‘llenando’ los elementos de la matriz a medida que avanza, ya están llenos, solo con valores no inicializados. No hay forma de probar un elemento no inicializado en una matriz.

Parece que desea utilizar una estructura de datos como un cola o pila o vector.

estoy totalmente de acuerdo con el vector cuando se implementa una matriz dinámica. Sin embargo, tenga en cuenta que STL le proporciona una gran cantidad de contenedores que se adaptan a diferentes requisitos de tiempo de ejecución. Debe elegir uno con cuidado. Por ejemplo: para una inserción rápida en la espalda, puede elegir entre un vector y un deque.

Y casi lo olvido, un gran poder conlleva una gran responsabilidad 🙂 Desde vectorLos s son de tamaño flexible, a menudo se reasignan automáticamente para ajustarse para agregar elementos. Así que tenga cuidado con la invalidación del iterador (sí, también se aplica a los punteros). Sin embargo, mientras esté usando operator[] para acceder a los elementos individuales está seguro.

Es posible que me esté perdiendo el punto de su pregunta aquí, y si es así, me disculpo. Pero, si no va a eliminar ningún elemento solo agregándolo, ¿por qué no simplemente asignar una variable a la siguiente ranura vacía? Cada vez que agregue un nuevo valor a la matriz, simplemente incremente el valor para apuntar al siguiente.

En C ++, una mejor solución es usar el tipo de biblioteca estándar std::list< type >que también permite que la matriz crezca dinámicamente, por ejemplo:

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