Lenguaje C: ¿Describe brevemente la relación entre matrices y punteros?
Matriz: Una matriz es una colección que se utiliza para almacenar múltiples datos del mismo tipo.
Puntero: Un puntero es equivalente a una variable, pero es diferente de diferentes variables. Almacena la dirección de otras variables en la memoria.
En segundo lugar, asignación, modo de almacenamiento, tamaño de, inicialización, etc.
1. Asignación
Las variables de puntero del mismo tipo se pueden asignar entre sí. pero las matrices no pueden. Sólo se pueden asignar o copiar uno por uno.
2. Modo de almacenamiento
Matriz: las matrices se almacenan continuamente en la memoria, creando así un espacio de memoria continuo. Se accede a los arreglos en función del contexto del arreglo, los arreglos multidimensionales se almacenan en la memoria en base a arreglos unidimensionales, pero lógicamente son multidimensionales.
El espacio de almacenamiento de la matriz está en el área estática o en la pila.
Puntero: El puntero es flexible y puede apuntar a cualquier tipo de dato. El tipo de puntero representa la memoria en el espacio de direcciones al que apunta.
Puntero: debido a que el puntero en sí es una variable y lo que almacena también es una variable, no se puede determinar el espacio de almacenamiento del puntero.
Buscando tamaño de
Matriz:
Memoria ocupada por matriz: tamaño de (nombre de matriz)
Tamaño de matriz: tamaño de (nombre de matriz) ) /sizeof (tipo de datos)
Puntero:
En plataformas de 32 bits, el tamaño del puntero es 4; en plataformas de 64 bits, el tamaño del puntero es 8.
En mi blog anterior escribí cómo encontrar el tamaño de con punteros y matrices, ahora publicaré el enlace:
/cherry dream sover/articles/details/81589838
Inicialización
Matriz:
(1) char a【】= {"Hola"} //Inicializado por cadena, el tamaño es 6. (2) char b【】= {'H', 'e', 'l', 'l'}; //Inicializar por carácter (error, la salida sin terminador será confusa) (3) char c【】 = { 'h', 'e', 'l', 'l', 'o', '\0'} // Inicializa 1234 por carácter.
Aquí agregamos un malentendido, que trata sobre la creación y destrucción de matrices, especialmente la creación y destrucción de matrices multidimensionales.
(1) Matriz unidimensional:
int * arr = new int【n】;//Crear matriz unidimensional
Eliminar【】arr // Destruir
②Matriz bidimensional:
int * * arr = new int *[row] // Esto es equivalente a crear una matriz que contenga cuántas filas.
for(int I = 0; i lt fila; i)
{
arr[I] = new int[col] //Aquí está creación.
}
//Liberar
for(int I = 0; i lt fila; i)
{
eliminar【】arr【I】;
}
Eliminar【】arr
Puntero:
//(1 ) Puntero al objeto: el valor en () es el valor de inicialización) int * p = new int (0); eliminar p // (2) Puntero a la matriz: (n representa el tamaño de la matriz, el valor; no es necesario determinarlo en tiempo de compilación, pero se puede determinar en tiempo de ejecución) int * p = new int [n]; eliminar [] p; son los parámetros después de la nueva Clase; de lo contrario, se llama al constructor predeterminado, eliminar llama al destructor) Clase * p = nueva Clase? Eliminar p; // (4) puntero del puntero: (puntero secundario) int * * PP = new (int *) [1]
PP [0] = new int [6]; 】PP【0】;12345678910
Aquí distinguimos dos conceptos importantes: matriz de punteros y puntero de matriz.
(1) Matriz de puntero: en realidad es una matriz, y cada elemento de la matriz almacena un elemento de tipo puntero.
int * arr[8]; //Problema de prioridad: [] tiene una prioridad mayor que *//Significa que arr es una matriz, int* es el contenido de la matriz//Esta oración significa arr es una matriz que contiene 8 e int* 1234.
Haga clic para ingresar una descripción de la imagen.
(2) Puntero de matriz: en realidad es un puntero a una matriz.
int (* arr) [8]; // Debido a que [] tiene una prioridad mayor que *, *arr debe estar entre paréntesis al escribir un puntero de matriz. //arr se combina con *first, lo que significa que P es una variable de puntero. // Esta oración significa que el puntero arr apunta a una matriz de 8 enteros. 1234
Haga clic para ingresar la descripción de la imagen.
En tercer lugar, pase la referencia
Matriz:
Cuando se pasa el parámetro de la matriz, degenerará en un puntero, así que primero echemos un vistazo a qué ¡La degeneración es!
(1) Significado degenerado: el lenguaje C solo pasa parámetros en forma de copia de valor. Al pasar parámetros, si simplemente copia toda la matriz, la eficiencia se reducirá considerablemente y, cuando los parámetros están en la pila, copiar una matriz que es demasiado grande provocará un desbordamiento de la pila.
(2) Por lo tanto, el lenguaje C simplifica el paso de parámetros de matrices. Cuando se copia toda la matriz en la función, el nombre de la matriz se trata como un puntero constante y se pasa la dirección del primer elemento de la matriz.
1. Pasar parámetros de matriz unidimensional
# include ltstdio.h gt//Pasar parámetros correctamente//Pasar parámetros en forma de matrices, y no es necesario especifique el tamaño de los parámetros porque al pasar parámetros en una matriz unidimensional, el parámetro formal en realidad no crea la matriz, sino que solo pasa la dirección del primer elemento de la matriz. (Si se pasa un valor de variable, el parámetro formal es una copia del parámetro real) void test (int arr[])
{ }//La forma de pasar parámetros es correcta//Ningún parámetro puede pasar, por supuesto, los parámetros también se pueden pasar como prueba nula (int arr [10]).
{ }//La forma de pasar parámetros es correcta. //A la matriz unidimensional se le pasa el argumento degenerado, que se recibe a través de un puntero que pasa la prueba nula para la dirección del primer elemento de la matriz (int *arr).
{ }//Los parámetros se pasan correctamente/* ARR[20] es una matriz de puntero y se pasa el nombre de la matriz void test2 (int * ARR[20]).
{ }//El parámetro se pasa correctamente//Es el nombre de la matriz de puntero, que indica la dirección del primer elemento. El primer elemento es un puntero a la matriz, luego obtiene la dirección, lo que significa que el puntero secundario, el puntero secundario recibe la prueba nula 2 (int * * arr).
{}int main()
{ int arreglo【10】= { 0 }; int * arreglo 2【20】= { 0 }; Prueba (arr);
prueba 2 (arr 2);
}
2. Pasar los parámetros de la matriz bidimensional
<. p>/ / Pasa los parámetros correctamente // Indica el tamaño del array bidimensional, con tres filas y cinco columnas void test (int arr [3] [5]).{ }//Los parámetros pasados son incorrectos// Los dos corchetes de la matriz bidimensional no pueden estar vacíos, el segundo no puede estar vacío, solo el primero puede estar vacío void test( intarr【】【】).
{ }//Los parámetros se pasan correctamente//Se puede escribir así, pero no como prueba Intarr[3][]void (Intarr[][5]).
{ }//Paso incorrecto de parámetros//arr es un puntero de primer nivel y se puede pasar a una matriz bidimensional, pero la prueba nula (int * arr) no se puede leer correctamente.
{ }//Transferencia de parámetros incorrecta//El parámetro aquí es una matriz de puntero, que es unidimensional y se puede pasar, pero los datos leídos son prueba nula incorrecta (int * arr [5]) .
{ } // Pasar parámetros correctamente // Pasar el nombre de la matriz de la matriz bidimensional, es decir, la dirección del primer elemento de la matriz, es decir, la dirección de la primera fila, que también es una matriz. Utilice el puntero de la matriz para recibir la prueba nula (int(*arr)[5]).
{ }//Paso de parámetros incorrecto//Se pueden pasar parámetros, pero habrá diversos grados de problemas al leer la prueba nula (int * * arr).
{}int main()
{ int arr【3】【5】= { 0 }
Prueba (arr);
}
Puntero:
1. Parámetros de paso de puntero de primer nivel
Cuando la parte del parámetro de función es un puntero de primer nivel, ¿qué parámetros pueden ¿ser aceptado? Por ejemplo prueba (int * p).
(1) puede ser un puntero a un número entero.
② Puede ser una dirección de variable entera.
(3) puede ser el nombre de una matriz de enteros unidimensionales.
# include ltstdio.h gtvoid print (int * p, int sz)
{ int I = 0; for (I = 0; i ltSZ; i )
{ printf("d\n",*(p I));
}
}int main()
{ int arr【 10] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; int * p = arrint SZ = tamaño de (arr)/tamaño de (arr [0]); se pasa Print (p, SZ) a la función; devuelve 0;
}
2. Parámetros de transferencia del puntero secundario
Es decir, cuando el parámetro de la función. La parte es un puntero secundario. Qué parámetros se pueden aceptar, como: prueba (int * * p).
(1) Variable de puntero auxiliar
(2) Dirección de la primera variable de puntero
(3) Nombre de matriz de matriz de puntero unidimensional
# include ltstdio.h gt void test (puntero ** interno)
{ printf("num=d\n", **ptr);
} int main( )
{ int num = 10; int * p = ampnumint * * pp = ampp
Prueba (PP); 0;
}
4. Puntero de función, matriz de puntero de función, puntero de matriz de función
1. ()
{printf ("jeje\n");
}//pfun puede almacenar la dirección de la función de prueba void (*pfun) ();
Forma del puntero de función: tipo (*), por ejemplo: int(*p)(). Puede almacenar la dirección de una función y también es muy común en aplicaciones normales.
2. Matriz de punteros de función
Forma: por ejemplo int (* p【10】)(
Porque p se combina primero con [], Esto significa que p es una matriz y el contenido de la matriz es un puntero int (*).
Las matrices de punteros de función se utilizan ampliamente en las tablas de conversión.
3. Puntero a una matriz de punteros de función
Un puntero a una matriz de punteros de función, es decir, el puntero apunta a una matriz cuyos elementos son todos punteros de función.
prueba nula(const char* str)
{ printf("s\n",str);
}int main()
{//Puntero de función pfun void (* pfun) (const char *) = test; //Matriz de puntero de función pfunarrvoid (* pfunarr[5]) (const char * str);
pfunArr【0】= prueba; //Puntero pfunArrvoid (*(*ppfunarr)【10】)(const char *)=;pfunArr devuelve 0;
}