Tutoriales

C++ Cambiar el tamaño de la matriz

Una vez que se ha asignado una matriz, no existe un mecanismo integrado para cambiar su tamaño en el lenguaje de programación C++. Por lo tanto, podemos evitar este problema generando dinámicamente una nueva matriz, copiando el contenido y luego eliminando la matriz anterior. Este artículo se centra en cómo asignar memoria dinámicamente en una matriz y ajustar el tamaño de la matriz en función de la entrada del usuario. Es una estrategia muy importante en la programación ya que asegura la utilización eficiente de la memoria. Cuando intentamos insertar un elemento nuevo en una matriz dinámica, aumenta automáticamente hasta que no hay más almacenamiento para el elemento nuevo. Típicamente, la región duplica su tamaño.

¿Qué es una matriz dinámica?

Una matriz dinámica es idéntica a una matriz estándar en apariencia, pero su tamaño se puede cambiar mientras se ejecuta el código. Los componentes de matriz dinámica ocupan un bloque de memoria contiguo. Una vez definida una matriz, no es posible modificar su tamaño. Por el contrario, una matriz dinámica no es como una matriz estática. Incluso después de haber sido ocupada, una matriz dinámica puede ampliar su tamaño. Los elementos se pueden agregar constantemente en la posición final de la matriz dinámica utilizando el espacio reservado hasta que esté completamente ocupado.

Factores clave de matriz dinámica en C++:

El rendimiento de la matriz está determinado por su tamaño inicial y su factor de crecimiento. Toma nota de los siguientes puntos:

  • Si una matriz es de tamaño modesto y tiene un factor de crecimiento más lento, seguirá reasignando memoria con más frecuencia. Como resultado, el rendimiento de la matriz se verá afectado.
  • Si una matriz es más grande y tiene un factor de crecimiento alto, tendrá una gran cantidad de memoria sin usar. Como resultado, los procesos de cambio de tamaño pueden llevar más tiempo. El rendimiento de la matriz también se verá afectado como resultado

Ejemplo 1:

La nueva palabra clave se usa para construir una matriz dinámica en el siguiente programa de C++. Después de eso, la palabra clave devuelve una referencia al primer elemento. La sección de encabezado tiene el archivo de biblioteca iostream incluido para usar sus métodos. También se incluye el archivo de espacio de nombres que permite utilizar su clase sin ser llamado. Luego se invoca la función principal en la que hemos declarado dos variables “p” y “num” de tipo de dato entero.

LEER  Código completo de Linux en español

En el siguiente paso, la declaración cout imprime la declaración «Ingrese los números». El comando cin toma la entrada del usuario y la asigna a la variable «num». El siguiente paso tiene la variable de puntero «Array» que contiene los valores enteros de la variable «num». El número ingresado por el usuario se imprimirá usando el comando cout. Entonces tenemos para condición de bucle que itera sobre cada elemento ingresado por el usuario. La matriz como «Array» se declara en el comando cin que lee la entrada ingresada por el usuario.

Después de la terminación del bucle, la declaración «sus números son» se imprimirá en la pantalla de la consola. Nuevamente, tenemos un para condición de bucle pero esta vez esta para condición de bucle itera sobre una matriz de elementos. Tenga en cuenta que hemos permitido que un usuario establezca el tamaño de la matriz. Como resultado, el tamaño de la matriz se define en tiempo de ejecución.

#incluir

usando el espacio de nombres estándar;
En t principal() {
En t pags, número;
cout< «Ingrese los números:» <>número;
En t *Formación = nuevo En t(número);
cout< «Ingresar « < número < «números» <final;
por (pags = ; pags > Formación[p];
}
cout< «Sus números son: «;
por (pags = ; pags < número; pags++) {
cout< Formación[p] < » «;
}
cout< «\norte «;
devolver ;
}

Se le solicita al usuario que ingrese el número en el indicador de la consola. Después de la entrada, el número para el tamaño de la matriz muestra los números del tamaño de matriz especificado. La matriz resultante se muestra en el indicador de la consola de Ubuntu.

Ejemplo 2:

Se puede usar una lista de inicializadores para establecer una matriz dinámica. Ilustremos esto con un ejemplo para ver cómo funciona. Primero, agregamos el archivo iostream y el archivo de espacio de nombres estándar en la sección de encabezado. Después de eso, invocamos la función principal. La lógica del programa debe incluirse en el cuerpo de la función. Entonces hemos definido una variable como “a” de tipo de dato entero.

Después de declarar la variable entera, tenemos una declaración de matriz dinámica como «Arr» que usa una lista de inicializadores. Tenemos cuatro entradas enteras en la matriz. El comando cout imprimirá la declaración «Elementos de la matriz» antes de mostrar los elementos de la matriz.

En el siguiente paso, tenemos un bucle for que itera sobre los elementos presentes en una matriz específica. A través del comando cout, los elementos de la matriz dada se imprimirán en el indicador de la consola.

#incluir

usando el espacio de nombres estándar;
En t principal(vacío) {
En t a;
En t *Arr{ nuevo En t[4]{ 9, 23, 1, 17 } };
cout< «Elementos de la matriz:» <final;
por (a = ; a < 4; a++) {
cout<Arr[a] <final;
}
devolver ;
}

El siguiente es el resultado que obtuvimos de la ejecución del programa anterior:

Ejemplo 3:

Una vez que se ha logrado el objetivo de la matriz dinámica, debe eliminarse de la memoria de la computadora. La expresión de eliminación se puede usar para hacer esto, de modo que el espacio de memoria esté libre y se use para almacenar datos adicionales. Tenemos que usar eliminar[] para eliminar la matriz dinámica de la memoria del sistema. el corchete [] con la palabra clave delete ordena a la CPU que elimine muchas variables en lugar de solo una.

Comencemos la implementación del programa. Hemos importado el archivo requerido en la sección de encabezado. Entonces, se llama a la función principal. Las variables enteras «i» y «no» se declaran en la función principal. Después de definir estas variables, tenemos la instrucción cout «Número de entrada» que es para que el usuario ingrese el número. Obtenemos un número del usuario y lo guardamos en la variable «no» usando el comando cin.

Luego, declare una variable de puntero «MyArr» que almacena los enteros en la memoria. El número ingresado por el usuario se imprimirá en el segundo comando cout de este programa. los en bucle se utiliza para la iteración sobre el número ingresado por el usuario. Al final, hemos construido la eliminación.[] declaración que borra la matriz dada en el programa y libera espacio en la memoria.

#incluir

usando el espacio de nombres estándar;
En t principal() {
En t i, no;
cout< «Número de entrada:» <>no;
En t *MiArr = nuevo En t(no);
cout< «Aporte « < no < «números» <final;
por (i = ; i>MiArr[i];
}
cout< «Los números de entrada son: «;
por (i = ; i< no; i++) {
cout<MiArr[i] < » «;
}
cout<final;
Eliminar [] MiArr;
devolver ;
}

Tras la ejecución del programa, obtuvimos el siguiente resultado. Cuando finalice el programa, se eliminará la matriz.

Ejemplo 4:

Podemos definir una matriz de punteros de tamaño «X» dinámicamente y luego asignar memoria de tamaño «Y» dinámicamente para cada fila que se ve en el siguiente ejemplo. Al principio, hemos definido la matriz en la sección de encabezado. En el siguiente paso, tenemos la función principal donde tenemos una variable de puntero «arr». La variable de puntero contiene la matriz de tamaño «X».

Ahora el para sentencia de bucle asigna a cada fila un tamaño de memoria «Y». Luego, tenemos un bucle anidado para asignar valores dinámicamente a una memoria que se ha asignado. La función rand generará un número aleatorio para la matriz 2D. En el siguiente ciclo anidado, hemos impreso la matriz 2D a través de la instrucción std::cout. Al finalizar el programa, la matriz 2D especificada se borrará del espacio de memoria asignado como hemos usado eliminar[] en el final.

#incluir

#definir X 3
#definir Y 4
En t principal()
{
En t** Arr = nuevo En t*[X];
por (En t i = ; i< X; i++) {
Arr[i] = nuevo En t[Y];
}
por (En t i = ; i< X; i++)
{
por (En t j = ; j < Y; j++) {
Arr[i][j] = rand() % 10;
}
}
por (En t i = ; i< X; i++)
{
por (En t j = ; j < Y; j++) {
estándar::cout<Arr[i][j] < » «;
}
estándar::cout< estándar::final;
}
por (En t i = ; i< X; i++) {
Eliminar[] Arr[i];
}
Eliminar[] Arr;

devolver ;
}

La matriz 2D se ha generado y se muestra en la pantalla de la consola a continuación.

Conclusión

Eso es sobre la matriz redimensionada en c ++. Nos dimos cuenta de que las matrices de C++ no tienen un método integrado para cambiar el tamaño. Pero a través de la asignación dinámica de matrices en C++, se puede modificar el tamaño de la matriz. Hemos ilustrado en el ejemplo para cambiar el tamaño de la matriz dinámica usando una nueva palabra clave. Además, podemos usar una lista de inicializadores para inicializar una matriz. Después de cambiar el tamaño, también podemos liberar espacio en la memoria usando eliminar[]. Este artículo le mostrará cómo cambiar el tamaño de una matriz en C++.

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba