Un arreglo es una serie de elementos del mismo tipo colocados en ubicaciones de memoria contiguas que pueden ser referenciados individualmente añadiendo un índice a un identificador único.
Esto significa que, por ejemplo, se pueden declarar cinco valores de tipo int como una tabla sin tener que declarar 5 variables diferentes (cada una con su propio identificador. En su lugar, mediante una tabla, los cinco valores int se almacenan en ubicaciones de memoria contiguas y es posible acceder a los cinco utilizando el mismo identificador, con el índice correcto.
Por ejemplo, una matriz que contenga 5 valores enteros del tipo int llamado toto podría ser representada por:
toto:
donde cada panel en blanco representa un elemento de la tabla. En este caso, se trata de valores del tipo int. Estos elementos se numeran de 0 a 4, siendo 0 el primero y 4 el último; en C ++, el primer elemento de un array se numera siempre con un cero (no con uno), independientemente de su longitud.
Como una variable normal, una tabla debe ser declarada antes de su uso. Una declaración típica para una tabla en C++ es:
escriba el nombre[elementos];
donde type es un tipo válido (como int, float…), name es un identificador válido y el campo elements (que siempre se coloca entre paréntesis []), especifica la longitud del array en términos de número de elementos.
Por lo tanto, la tabla toto, con cinco elementos de tipo int, puede ser declarada como:
int toto[5];
NOTA: El campo de elementos entre corchetes [], que representa el número de elementos de la matriz, debe ser una expresión constante, ya que las matrices son bloques de memoria estática cuyo tamaño debe determinarse en el momento de la compilación, antes de ejecutar el programa.
Inicialización de tablas
Por defecto, las tablas clásicas de alcance local (por ejemplo, las declaradas en una función) no se inicializan. Esto significa que ninguno de sus elementos está definido sobre un valor particular; su contenido es indeterminado en el momento en que se declara la tabla.
Pero los elementos de una tabla pueden ser inicializados explícitamente con valores específicos cuando se declara, rodeándolos entre paréntesis {}. Por ejemplo:
int toto[5] = {9, 3, 15, 20, 2007};Esta declaración declara una tabla que puede ser representada de la siguiente manera:
toto:
El número de valores entre paréntesis {} no debe exceder el número de elementos de la tabla. Por ejemplo, en el ejemplo anterior, toto fue reportado con 5 elementos (como lo indica el número entre paréntesis, []), y las llaves {} contenían exactamente 5 valores, uno para cada elemento. Si se declaran con menos, los elementos restantes se ajustan a sus valores por defecto (lo que, para los tipos fundamentales, significa que están llenos de ceros. Por ejemplo:
int titi[5] = {10, 20, 30};Ve a crear una tabla como esta:
titi :
Es posible que el inicializador no tenga ningún valor, sólo los frenos:
int porque[5] = {};
Esto crea un array de cinco valores int, cada uno inicializado con un valor de cero:
porque
Cuando se proporciona una inicialización de valor para un array, C ++ le permite dejar los corchetes vacíos []. En este caso, el compilador asumirá automáticamente un tamaño para el array que corresponde al número de valores incluidos entre las llaves {}:
int toto [] = {16, 2, 77, 40, 12071};Después de esta declaración, la tabla toto tendría una longitud de 5 int, ya que proporcionamos 5 valores de inicialización.
Por último, la evolución de C++ ha llevado a la adopción de la inicialización universal también para las tablas. Por lo tanto, el signo igual entre la declaración y el inicializador ya no es necesario. Estas dos afirmaciones son equivalentes:
int toto [] = {10, 20, 30};int toto [] {10, 20, 30};Las tablas estáticas y las declaradas directamente en un espacio de nombres (fuera de cualquier función) siempre se inicializan. Si no se especifica ningún inicializador explícito, todos los elementos se inicializan por defecto (con ceros, para tipos fundamentales.
Acceso a los valores de un array
Los valores de cualquier elemento de una tabla pueden ser vistos como el valor de una variable regular del mismo tipo. La sintaxis es la siguiente:
nombre[índice]
Siguiendo los ejemplos anteriores en los que toto tenía 5 elementos y cada uno de estos elementos era de tipo int, el nombre que se puede utilizar para referirse a cada elemento es el siguiente:
toto(0)toto(1)toto(2)toto(3)toto(4)
Por ejemplo, la siguiente instrucción almacena el valor 75 en el tercer elemento toto:
toto[2] = 75;
y, por ejemplo, lo siguiente copia el valor del tercer elemento toto en una variable llamada x:
x = toto[2];
Por lo tanto, la expresión toto[2] es en sí misma una variable int.
Nótese que el tercer elemento toto está especificado toto[2], ya que el primero es toto[0], el segundo es toto[1] y por lo tanto el tercero es toto[2]. Por la misma razón, su último elemento es toto[4]. Por lo tanto, si escribimos toto[5], accederíamos al sexto elemento toto y así excederíamos realmente el tamaño de la tabla.
En C++, es sintácticamente correcto exceder el rango de índice válido para un array. Esto puede crear problemas, porque el acceso a elementos fuera de alcance no causa errores durante la compilación, pero puede causar errores durante la ejecución. La razón de esta autorización se discutirá en un capítulo posterior cuando se introduzcan los punteros.
En esta etapa, es importante poder distinguir claramente los dos usos que los corchetes [] han asociado a las tablas. Realizan dos tareas diferentes: una es especificar el tamaño de las tablas cuando se declaran; y la segunda es especificar los índices de los elementos concretos de las tablas cuando se accede a ellas. No confundir estos dos posibles usos de los soportes [] con las tablas.
int toto[5]; // declaración de una nueva tabla[2] = 75; // acceso a un elemento de la tabla.
La principal diferencia es que la declaración está precedida por el tipo de elementos, mientras que el acceso no lo está.
Algunas otras operaciones válidas con tablas:
toto[0] = a;toto[a] = 75;b = toto[a + 2];toto[toto[a]] = toto[2] + 5;
Por ejemplo:
// ejemplo de tablas#incluye <iostream>usando namespace std;int toto [] = {16, 2, 77, 77, 40, 12071};int n, result = 0;int main (){ para (n = 0; n <5; ++ n) { resultado + = toto[n]; } coste <<< resultado; return 0;}Resultado
12206
Tablas multidimensionales
Las tablas multidimensionales pueden describirse como «tablas de tabla». Por ejemplo, una tabla bidimensional puede imaginarse como una tabla bidimensional compuesta de elementos, todos del mismo tipo de datos uniformes.
immy representa una matriz bidimensional de 3 por 5 elementos del tipo int. La sintaxis de C ++ utilizada es la siguiente:
int hed[3][5];
y, por ejemplo, cómo hacer referencia al segundo elemento verticalmente y al cuarto elemento horizontalmente en una expresión:
cobertura[1][3]
(recuerde que los índices de las tablas siempre empiezan por cero.
Las tablas multidimensionales no se limitan a dos índices (es decir, dos dimensiones. Pueden contener tantas pistas como sea necesario. Tenga cuidado, la cantidad de memoria requerida para una tabla aumenta exponencialmente con cada dimensión. Por ejemplo:
cadena siecle[100][365][24][24][24][60][60][60][60];
declara una matriz con un elemento de tanque para cada segundo del siglo.
Esto representa más de 3 mil millones de caracteres! Por lo tanto, esta declaración consume más de 3 gigabytes de memoria!
Al final, las tablas multidimensionales son sólo una abstracción para los programadores, porque los mismos resultados se pueden obtener con una tabla simple, multiplicando sus índices:
int hed[3][5]; // es equivalente aint hed[15]; // (3 * 5 = 15)
La única diferencia es que con las tablas multidimensionales, el compilador recuerda automáticamente la profundidad de cada dimensión imaginaria. Las siguientes dos piezas de código producen exactamente el mismo resultado, pero una usa una tabla bidimensional, mientras que la otra usa una tabla simple:
Tabla multidimensionalPseudo tabla multidimensional#define WIDTH 5
#definir la altura 3int hed[ALTURA][ANCHO];
int n,m;int principal ()
{
para (n=0; n
para (m=0; m
{
hed[n][m]=(n+1)*(m+1);
}
Definición de la ANCHURA 5
#define HEIGHT 3int hed[HEIGHT * WIDTH];
int n,m;int principal ()
{
para (n=0; n
para (m=0; m
}
Ninguno de los
dos extractos de código anteriores produce una salida en la pantalla, pero ambos asignan valores al bloque de memoria llamado hed de la siguiente manera:
01234010101234545124681023691215Note
que el código usa constantes definidas para ancho y alto, en lugar de usar directamente sus valores numéricos
.
Esto le da al código una mejor legibilidad y hace que sea fácil cambiar el código en un solo lugar.
Tablas en parámetros
En algún momento, puede ser necesario pasar un array a una función como parámetro. En C++, no es posible transmitir todo el bloque de memoria representado por un array a una función directamente como argumento. Pero lo que se puede transmitir es su dirección. En la práctica, esto tiene casi el mismo efecto y es una operación mucho más rápida y eficiente.
Para aceptar un array como parámetro de una función, los parámetros pueden ser declarados como un tipo de array, pero con corchetes vacíos, omitiendo el tamaño real del array. Por ejemplo:
procedimiento de nulidad (int arg [])
Esta función acepta un parámetro de tipo «array of integers» llamado arg. Para pasar a esta función, una tabla declarada como:
int myarray[40];
sería suficiente para escribir una llamada como esta:
procedimiento (myarray);
Aquí tienes un ejemplo completo:
// tablas como parámetros#include <iostream>usando namespace std;void printarray (int arg [], int longitud int) { para (int n = 0; n <length; ++ n) coste <<<< arg[n] << coste << < < n''' en principal (){ int firstarray [] = {5, 10, 15}; int secondarray [] = {2, 4, 6, 8, 10}; printarray (firstarray, 3); printarray (secondarray, 5);}Resultado de la ejecución:
5 10 152 4 6 6 6 8 8 8 10Modificar y ejecutar
En el código anterior, el primer parámetro (int arg []) acepta cualquier array cuyos elementos sean de tipo int, independientemente de su longitud. Por esta razón, hemos incluido un segundo parámetro que indica a la función la longitud de cada tabla que le transmitimos como primer parámetro. Esto permite que el bucle de for que imprime la tabla conozca el rango para iterar en la tabla transmitida, sin salir del rango.
En una declaración de función, también es posible incluir tablas multidimensionales. El formato de un parámetro de matriz tridimensional es el siguiente:
type_base [][profundidad][profundidad][profundidad][profundidad]
Por ejemplo, una función con una matriz multidimensional como argumento podría ser:
procedimiento nulo (int myarray [][ 3]]][ 4])
Esto es necesario para que el compilador determine la profundidad de cada dimensión adicional.
En cierto modo, al pasar un array como argumento siempre se pierde una dimensión. La razón es que, por razones históricas, las tablas no pueden copiarse directamente, por lo que lo que realmente se pasa es un puntero. Esta es una fuente común de errores para los programadores novatos. Aunque una clara comprensión de los indicadores, explicada en un capítulo posterior,
Otros consejos interesantes:
- Cómo crear un eje de tiempo de una tabla pivotante en Excel 2013 Si está cansado de manipular las fechas en su tabla pivotante utilizando herramientas de filtrado torpes, Microsoft finalmente ha proporcionado una mejor manera.
- Cuerdas en C++ La clase de cuerda se introdujo brevemente en un capítulo anterior. Es una clase muy poderosa para manipular y manipular cuerdas. Sin embargo, como las cadenas son en realidad secuencias de……
- Memoria dinámica en C++ En los programas descritos en los capítulos anteriores, todos los requisitos de memoria se determinaron antes de ejecutar el programa mediante la definición de las variables necesarias. Pero puede suceder que las necesidades de memoria de un….
- Serie de ejercicios corregidos en C++ Aquí hay una lista de ejercicios corregidos en C++: Ejercicios 1 : Eliminar corchetes innecesarios en las siguientes expresiones: a = (x+5) /* expresión 1 */ a = (x=y) + 2 /* expresión….
- Punteros en C++ En los capítulos anteriores, las variables se han explicado como ubicaciones en la memoria del ordenador a las que se puede acceder mediante su identificador (nombre. De esta manera, el programa no necesita….