Una comprensión simple de las matrices en lenguaje C

formación

Introducción a las matrices

Una matriz es una serie de elementos del mismo tipo de datos. Al usar una matriz, primero debe declarar la matriz. De acuerdo con esta información, el compilador puede crear la matriz con éxito.

Ejemplo de declaración de matriz

float arr[30];//包含30个float类型的元素的集合
char arr1[20];//包含20个char类型元素的集合
int arr2[10];//包含10个int类型元素的集合

Pero no se puede declarar así.

int arr[];//错误

Formato de declaración de matriz

escribe un nombre[ ] ;

Primero el tipo de la matriz, luego el nombre de la matriz, "[ ]" se usa para indicar que el nombre es una matriz, y "[ ]" es el número de elementos en la matriz

inicializar la matriz

Cuando se crea una matriz, dar algunos valores iniciales se llama inicialización

Generalmente, la matriz se inicializa al comienzo del programa.

int arr[3] = {
    
    1,2,3};

Aquí se crea un arreglo arr con 3 elementos, {1,2,3} asigna 1 al primer elemento del arreglo, 2 al segundo elemento del arreglo y 3 al segundo elemento del arreglo da el tercer elemento de la matriz La coma entre "1,2,3" se utiliza para separar los valores para garantizar que no haya ningún error al asignar.

Hay otros métodos de inicialización.

char ch[] = "abc";
char ch1 = {
    
    'a','b','c'};
int arr[] = {
    
    1,2,3};//这个数组只有三个元素

Completamente inicializado:

Hay varias posiciones de elementos para dar el valor de varios elementos.

int arr[10] = {
    
    1,2,3,4,5,6,7,8,9,10};

Cuando el número de asignaciones excede el número de elementos, se informa un error:
demasiados inicializadores

int arr[3] = {
    
    1,2,3,4,}//初识值多了，这样的写法是错误的

Inicialización incompleta:

int arr[10] = {
    
    0};//全部都初始化为0
int arr[10] = {
    
    1,2,3};//后面的几个元素都被默认初始化为0

Inicialización de cadenas y caracteres

Cuando se inicializa la cadena: '\0'

int arr1[] = "abc";//a,b,c,\0————有四个元素，数组大小是四个字节
printf("%d",sizeeof(arr));//4
printf("%d",strlen(arr));//3__遇到\0就停止了，计算\0前面的

No hay carácter al inicializar: '\0'

int arr[] = {
    
    'a','b','c'};//a,b,c————有三个元素，数组大小是三个字节
printf("%d",sizeeof(arr));//3
printf("%d",strlen(arr));//随机值，遇不到\0

Almacenamiento de arreglos y subíndices

Al crear una matriz, se asigna un espacio contiguo en la memoria, por lo que las direcciones de los n elementos de la matriz son contiguas:

Para tal arreglo arr[3] = {1,2,3};

#include<stdio.h>
int main()
{
    
    
	int arr[3] = {
    
     1,2,3 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("%d", sz);
	return 0;
}

Entonces, ¿cómo podemos ver que se usan los diferentes elementos en la matriz? Aquí necesitamos usar el operador de referencia de subíndice "[]",

Creamos una nueva matriz e imprimimos sus diferentes elementos.

#include<stdio.h>
int main()
{
    
    
	int arr[3] = {
    
     100,200,300 };
	
	printf("arr[0] =%d\n", arr[0]);
	printf("arr[1] =%d\n", arr[1]);
	printf("arr[2] =%d\n", arr[2]);

	return 0;
}

Sabemos que los datos de 100 se almacenan en el primer elemento de la matriz, pero el subíndice del primer elemento de la matriz es 0, por lo que cuando imprimamos el valor de arr[0], aparecerá 100. Y así sucesivamente, el índice del segundo elemento de la matriz es 1, el índice del tercer elemento es 2...

Es importante saber qué elemento de la matriz corresponde a qué subíndice

Entrada y salida de elementos de matriz

Cuando procesamos muchos datos, usaremos matrices, y cuando hay muchos datos, tomará mucho tiempo ingresarlos y generarlos de la siguiente manera

Por ejemplo, si necesitamos ingresar 100 valores para salir en la matriz, entonces necesitamos ingresar 100 funciones scanf, y ¿necesitamos escribir 100 funciones printf al generar?

#include<stdio.h>
int main()
{
    
    
int arr[100] = {
    
    0};
    //输入
    scanf("%d",&arr[0]);
    scanf("%d",&arr[1]);
    scanf("%d",&arr[2]);
    ...
	scanf("%d",&arr[99]);
    //输出
    printf("%d",arr[0]);
    printf("%d",arr[1]);
    printf("%d",arr[2]);
    ...
    printf("%d",arr[99]);
return 0;
}

Obviamente, esto es muy problemático, y cuando necesitamos ingresar una gran cantidad de datos del mismo tipo e imprimir una serie de datos del mismo tipo, pensaremos en hacer un bucle.

Sí, el bucle puede resolver el problema anterior muy fácilmente.

#include<stdio.h>
int main()
{
    
    
    int arr[100] = {
    
    0};
   int i = 0;
    for(i = 0;i <100;i++)
    {
    
    
        scanf("%d",&arr[i]);
	}
    for(i = 0;i<100;i++)
    {
    
    
        printf("%d\n",arr[i]);
	}
    return 0;
}

El ciclo anterior puede resolver rápidamente el problema de entrada y salida, pero a veces la matriz que encontramos es así

int arr[] = {
    
    1,2,3,4,5,6,7,8,9,1,2,3};

Dicha inicialización de matriz es legal, pero cuando se realiza un ciclo, necesitamos saber cuándo terminar el ciclo. Al ejecutar la matriz que imprime 100 elementos arriba, sabemos claramente que hay 100 elementos, por lo tanto, realice un ciclo dentro de la condición de i<100, pero actualmente, en esta matriz, no podemos determinar cuántos elementos hay presionando fuerte ¿Por qué podemos usar tal expresión para calcular la cantidad de elementos en la matriz?

int sz = sizeof(array)/sizeof(array[0]);

//这里相当于创建了一个整形变量，来储存表达式sizeof(array)/sizeof(array[0])的结果
/*对于等号后面的表达式：sizeof(),
如果括号里面的是单个数组名，那么sizeof(array)计算的就是整个array数组的大小（单位字节）
如果括号里面的是单个数组元素，那么计算的四则偶分（array[0])计算的就是这个元素的大小（单位字节）
*/

Entonces el siguiente es el código para imprimir la matriz de int arr[] = {1,2,3,4,5,6,7,8,9,1,2,3}

#include<stdio.h>
int main()
{
    
    
	int arr[] = {
    
     1,2,3,4,5,6,7,8,9,1,2,3 };
	int sz = sizeof(arr) / sizeof(arr[0]);//这里计算出了数组元素的个数
	int i = 0;
	for (i = 0; i < sz; i++)
	{
    
    
		printf("arr[%d] = %d\n", i,arr[i]);
	}
	return 0;
}

matriz fuera de los límites

Los arreglos están acotados

Al usar la matriz, debe tener cuidado de no exceder el subíndice de la matriz, es decir, si la matriz que crea es arr[20], cuando se llame al subíndice, use el subíndice de 0-19, de lo contrario, el la matriz estará fuera de los límites

Sabemos que la matriz usa un espacio continuo cuando se crea, por lo que las direcciones de varios elementos de la matriz son continuas.Cuando la matriz está fuera de los límites,

O toma este ejemplo:

int arr[20]= {
    
    0};
//当我们在打印的时后错误使用了：
printf("%d",arr[-1]);
printf("%d",arr[20]);
//这两种下标都超出了数组的边界
//这时arr[-1]的地址在数组地址前面
//arr[20]的地址在数组地址后面


//如果arr[-1]的地址上没有赋值，那么打印出来的就是一堆乱码，arr[20]也一样
    
    

Los compiladores generalmente no verifican problemas como una matriz fuera de los límites

Creación e inicialización de arreglos bidimensionales

Creación de una matriz bidimensional

La creación de arreglos bidimensionales tiene muchas similitudes con los arreglos unidimensionales: como tipos de arreglos, nombres de arreglos y el operador [ ].

También hay diferentes lugares:

int arr[2] = {
    
    1,2};
int arr1[2][2] = {
    
    1,2,3,4};

Una matriz bidimensional se crea con un símbolo [ ] adicional, lo que equivale a crear una dimensión adicional.

El número total de elementos en una matriz bidimensional es igual al producto de los dos números entre paréntesis

int arr[3][4];//有 12 个元素
int arr[5][5];//有 25 个元素

Una matriz de este tipo también se puede entender como: arr es un conjunto grande, el siguiente contiene tres conjuntos pequeños arr[0], arr[1], arr[2], cada faceta del conjunto incluye varios conjuntos más pequeños

Inicialización de una matriz bidimensional

Hay muchas formas de inicializar arreglos bidimensionales y diferentes métodos tienen diferentes efectos de inicialización.

int arr[3][5] = {
   
   {1,2},{1,2},{3,2}};

Se puede ver que esta inicialización es para asignar los primeros elementos de arr[0], los primeros elementos de arr[1], los primeros elementos de arr[3] y el resto de los elementos se asignan a 0 ;

almacenamiento de matrices bidimensionales

Los arreglos bidimensionales son muy similares a los arreglos unidimensionales en términos de almacenamiento, ambos usan espacio continuo, pero el "continuo" almacenado en los arreglos bidimensionales es la dirección del elemento de un pequeño conjunto de valores seguido del primero de el siguiente conjunto pequeño dirección del elemento

Esta imagen muestra que la dirección de
arr[0][4] es: 0x00AFF834 La dirección de
arr[1][0] es: 0x00AFF838 Las
dos direcciones son consecutivas, lo que confirma la conclusión anterior.

Las filas de arreglos bidimensionales se pueden omitir, pero las columnas no se pueden omitir

int arr[2][3] ={
    
    1,2,3,4,5,6}//一个含有六个元素的数组
int arr[][3] = {
    
    1,2,3,4,5,6}//与上面的结果相同
int arr[2][] = {
    
    1,2,3,4,5,6}
/*第三个是错误的，会造成歧义，系统只知道要创建两个六个空间分两部分使用，
但是不知道每一个空间分配多少个元素，造成报错*/

arreglos y funciones

Elementos de matriz como argumentos para funciones

Los elementos de matriz se pueden usar como parámetros reales de funciones, pero no como parámetros formales (los parámetros formales se asignan temporalmente en el espacio por unidad, y una unidad no se asignará solo para un elemento de matriz). Al pasar, simplemente pase el valor del elemento de la matriz al parámetro formal, aquí usamos un ejemplo para ilustrar el "paso de valor" del elemento de la matriz como un argumento de función

Ejemplo: ingrese diez números en una matriz e imprima el mayor de los diez números

#include<stdio.h>
int MAX(int x,int y)
{
    
    
	return x > y ? x : y;
}//比较函数
int main()
{
    
    

	int arr[10] = {
    
     0 };
	int i = 0;
	for (i = 0; i < 10; i++)
	{
    
    
		scanf("%d", &arr[i]);
	}//读取十个数
	int max = 0;
	for (i = 0; i < 10; i++)
	{
    
    
		max = MAX(arr[i], max);
            //arr[i]作为函数实参，将arr[i]的值传给了形参x

	}//作比较 
    
	printf("max = %d\n", max);
    
    for (i = 0; i < 10; i++)
	{
    
    
		printf("arr[%d] = %d\n", i, arr[i]);

	}
	return 0;
}
//输入1 2 10 9 8 7 6 5 4 3  
//打印的是：max = 10;

Se puede ver que el valor de cada elemento del arreglo no cambia después de ser usado como parámetro de función.Se puede confirmar que cuando el elemento del arreglo se usa como parámetro real, solo se pasa su propio valor al parámetro formal.

nombre de matriz como parámetro de función

A diferencia de los elementos del grupo de pinceles, el nombre de la matriz se puede usar no solo como el parámetro real de la función, sino también como el parámetro formal de la función.

Cuando se utiliza el nombre de la matriz como parámetro real de la función, se pasa la dirección del primer elemento. En muchos casos, el nombre de la matriz representa la dirección del primer elemento.

De manera similar, aquí hay un ejemplo para ilustrar el caso en el que el nombre de la matriz se usa como parámetro

#include<stdio.h>

int average(int arr[])
    //实参对应的形参指定和实参一样的类型
    //形参的数组可以不指定大小
    //
{
    
    
	int i = 0;
	int sum = arr[0];
	for (i = 1; i < 10; i++)
	{
    
    
		sum += arr[i];
	}
	return sum / 10;
}
int main()
{
    
    
	int score[10] = {
    
     0 };
	int i = 0;
	for (i = 0; i < 10; i++)
	{
    
    
		scanf("%d", &score[i]);
	}
	int aver = average(score);//函数名做实参
	printf(" %d\n", aver);
	return 0;
}

Se puede considerar que la dirección del primer elemento del grupo de parámetros formales es la misma que la dirección del primer elemento del grupo de parámetros reales, se comunican y ocupan la misma unidad, y el grupo de parámetros reales y el parámetro formal correspondiente grupo tienen el mismo valor.