Estructuras y punteros
estructura
Una estructura en lenguaje C es un tipo de datos personalizado que nos permite combinar diferentes tipos de datos para formar un nuevo tipo de datos. Las estructuras pueden contener diferentes tipos de datos, como números enteros, caracteres, números de punto flotante, matrices, etc., y pueden usarse para describir estructuras de datos complejas. La estructura en lenguaje C se introducirá en detalle a continuación, incluyendo la definición de la estructura, la declaración e inicialización de la variable de estructura y el acceso a los miembros de la estructura.
1. Definición de estructura
La definición de la estructura utiliza la palabra clave struct y su sintaxis es la siguiente:
struct estructura nombre {
nombre de miembro de tipo de datos 1;
nombre de miembro de tipo de datos 2;
nombre de miembro de tipo de datos 3;
...
};
Entre ellos, el nombre de la estructura es nuestro nombre personalizado, el nombre del miembro es el nombre con el que nombramos a cada elemento de la estructura y el tipo de datos puede ser cualquier tipo de datos del lenguaje C u otros tipos de estructuras.
Por ejemplo, podemos definir una estructura para representar la información de un estudiante, incluido el nombre, la edad, el sexo, el número de estudiante y las calificaciones, etc. El código es el siguiente:
struct Student {
char name[20];
int age;
char sex;
char id[10];
float score;
};
En el código anterior, definimos una estructura llamada Estudiante, que contiene 5 miembros, a saber, nombre, edad, género, número de estudiante y calificación, y sus tipos de datos son char, int, char, char y float.
2. Declaración e inicialización de variables de estructura
Una vez definida la estructura, podemos declarar variables de estructura e inicializarlas. Hay dos formas de declarar e inicializar variables de estructura, a saber:
1. Declarar primero y luego inicializar
struct Student stu;
stu.age = 18;
strcpy(stu.name, "Tom");
stu.sex = 'M';
strcpy(stu.id, "2018001");
stu.score = 95.0;
En el código anterior, primero declaramos una variable de estructura llamada stu del tipo Student y luego inicializamos sus miembros.
2. Declaración e inicialización simultáneas
struct Student stu = {
"Tom", 18, 'M', "2018001", 95.0};
En el código anterior, inicializamos la variable de estructura stu mientras la declaramos, y el orden de inicialización es consistente con el orden de definición de miembro.
3. Acceso a los miembros de la estructura
El acceso a los miembros de la estructura utiliza el operador " . ", por ejemplo:
printf("姓名：%s\n", stu.name);
printf("年龄：%d\n", stu.age);
printf("性别：%c\n", stu.sex);
printf("学号：%s\n", stu.id);
printf("成绩：%f\n", stu.score);
En el código anterior, usamos el operador "." para acceder a cada miembro de la variable de estructura stu y luego mostrar sus valores.
Cuarto, la estructura como parámetro de función.
Las estructuras se pueden utilizar como parámetros de funciones, por ejemplo:
void printStudent(struct Student s) {
printf("姓名：%s\n", s.name);
printf("年龄：%d\n", s.age);
printf("性别：%c\n", s.sex);
printf("学号：%s\n", s.id);
printf("成绩：%f\n", s.score);
}
En el código anterior, definimos una función llamada imprimirEstudiante, cuyo parámetro es una variable de estructura s de tipo Estudiante, y luego generamos los miembros de la variable s.
Cinco, código completo
El siguiente es un ejemplo completo del uso de una estructura, que define una estructura llamada Student, declara una variable de estructura llamada stu, la inicializa y finalmente genera los miembros de la variable stu.
#include <stdio.h>
#include <string.h>
struct Student {
char name[20];
int age;
char sex;
char id[10];
float score;
};
void printStudent(struct Student s) {
printf("姓名：%s\n", s.name);
printf("年龄：%d\n", s.age);
printf("性别：%c\n", s.sex);
printf("学号：%s\n", s.id);
printf("成绩：%f\n", s.score);
}
int main() {
struct Student stu = {
"Tom", 18, 'M', "2018001", 95.0};
printStudent(stu);
return 0;
}
El resultado de la operación es el siguiente:
姓名：Tom
年龄：18
性别：M
学号：2018001
成绩：95.000000
6. Resumen
Este artículo introduce la estructura en lenguaje C, incluyendo la definición de la estructura, la declaración e inicialización de la variable de estructura, el acceso a los miembros de la estructura y la estructura como parámetro de función, etc. La estructura es un tipo de datos muy importante, que se puede utilizar para describir estructuras de datos complejas, lo cual es conveniente para la escritura y el mantenimiento de programas.
puntero
El puntero es un concepto muy importante en el lenguaje C, y también es uno de los conceptos más difíciles de entender para los principiantes. La esencia de un puntero es una dirección, que apunta a una ubicación donde se almacenan los datos. A través del puntero, podemos acceder y manipular los datos almacenados en esta ubicación. A continuación, se explicarán en detalle los conceptos relacionados y el uso de punteros en lenguaje C, con un código detallado y una explicación del código.
1. Definición de puntero
El formato de definición del puntero es: * nombre de variable de puntero de tipo de datos ; donde, el tipo de datos indica el tipo de datos al que apunta el puntero, y el nombre de variable de puntero es un identificador utilizado para indicar la posición de la variable de puntero en la memoria . Por ejemplo:
int *p; //定义一个指向整型数据的指针变量
Al definir una variable de puntero, es necesario especificar el tipo de datos al que apunta el puntero. Esto se debe a que los diferentes tipos de datos ocupan diferentes tamaños de espacio de almacenamiento y los punteros necesitan saber el tamaño del tipo de datos al que apuntan para realizar las operaciones de puntero correctamente.
En segundo lugar, la inicialización del puntero.
La variable de puntero no apunta automáticamente a una determinada dirección cuando se define y debe inicializarse para apuntar la variable de puntero a una dirección de memoria legal. Las variables de puntero se pueden inicializar de las siguientes maneras:
① Asignación directa: Asigne la variable puntero a una dirección conocida.
int a = 10;
int *p = &a; //将指针p指向变量a的地址
② Asigna memoria dinámicamente a través de la función malloc:
int *p = (int *)malloc(sizeof(int)); //动态分配一个整型数据的内存空间，并将指针p指向这个空间的地址
③ Inicializar por valor de retorno de función:
int *get_array(int size) {
int *p = (int *)malloc(size * sizeof(int));
return p;
}
int *arr = get_array(10); //将指针arr指向动态分配的数组的首地址
Tres, operación de puntero
Las variables de puntero se pueden sumar y restar, y la dirección apuntada se compensará según el resultado de la operación. Por ejemplo:
int a[5] = {
1, 2, 3, 4, 5};
int *p = a; //将指针p指向数组a的首地址
for (int i = 0; i < 5; i++) {
printf("%d ", *p); //输出指针p所指向的数据
p++; //指针p指向下一个数据
}
En el código anterior, el puntero p primero apunta a la primera dirección de la matriz a, y luego usa la aritmética de punteros para acceder a cada elemento de la matriz y generar sus valores.
Las variables de puntero también pueden realizar operaciones de comparación, comparando si las direcciones a las que apuntan son las mismas. Por ejemplo:
int a = 10, b = 20;
int *p1 = &a, *p2 = &b;
if (p1 > p2) {
printf("p1指向的地址大于p2\n");
} else {
printf("p1指向的地址小于等于p2\n");
}
En el código anterior, a través de la comparación de las variables de puntero p1 y p2, se juzga el tamaño de la dirección a la que apuntan y se emite el resultado correspondiente.
En cuarto lugar, la aplicación del puntero.
Los punteros son ampliamente utilizados en lenguaje C y se pueden utilizar en los siguientes aspectos:
① Asignación dinámica de memoria: el espacio de memoria se puede asignar dinámicamente a través de la función de puntero y malloc, lo que evita el problema del desperdicio de memoria durante la asignación estática.
② Paso de parámetros de función: los parámetros de función se pueden pasar a través de punteros, y los resultados del cálculo dentro de la función se pueden devolver a la persona que llama.
void swap(int *x, int *y) {
int temp = *x;
*x = *y;
*y = temp;
}
int a = 10, b = 20;
swap(&a, &b); //将变量a和b的值交换
En el código anterior, la función de la función se realiza intercambiando los valores de las variables a y b a través del puntero.
③ Acceso a la matriz: el nombre de la matriz es esencialmente un puntero a la primera dirección de la matriz, y se puede acceder a cada elemento de la matriz a través del puntero.
int a[5] = {
1, 2, 3, 4, 5};
int *p = a; //将指针p指向数组a的首地址
for (int i = 0; i < 5; i++) {
printf("%d ", *(p + i)); //输出数组中的每个元素
}
En el código anterior, se accede a cada elemento de la matriz a a través del puntero p, y se emiten sus valores.
5. Precauciones para punteros
Los punteros deben prestar atención a los siguientes puntos al usar:
① Las variables de puntero deben inicializarse antes de que puedan usarse.
② Las variables de puntero no pueden acceder al espacio de memoria no asignado; de lo contrario, el programa fallará.
③ La variable del puntero debe apuntar al tipo de datos correcto, de lo contrario, provocará un error de operación del puntero.
④ Al usar variables de puntero, debe prestar atención al problema de límites de la aritmética de punteros para evitar el acceso fuera de los límites.
6. Código de ejemplo
El siguiente es un código de muestra completo que demuestra la definición, inicialización, operación y aplicación de punteros:
#include <stdio.h>
#include <stdlib.h>
void swap(int *x, int *y) {
int temp = *x;
*x = *y;
*y = temp;
}
int *get_array(int size) {
int *p = (int *)malloc(size * sizeof(int));
return p;
}
int main() {
int a = 10, b = 20;
int *p1 = &a, *p2 = &b;
if (p1 > p2) {
printf("p1指向的地址大于p2\n");
} else {
printf("p1指向的地址小于等于p2\n");
}
int arr[5] = {
1, 2, 3, 4, 5};
int *p = arr;
for (int i = 0; i < 5; i++) {
printf("%d ", *(p + i));
}
printf("\n");
int *arr2 = get_array(10);
for (int i = 0; i < 10; i++) {
*(arr2 + i) = i;
printf("%d ", *(arr2 + i));
}
printf("\n");
swap(&a, &b);
printf("a=%d, b=%d\n", a, b);
free(arr2);
return 0;
}
En el código anterior, se definen dos variables de puntero p1 y p2, y los resultados correspondientes se muestran comparando los tamaños de las direcciones a las que apuntan. Luego se define una matriz arr, se accede a cada elemento de la matriz a través de la variable de puntero p, y se emiten sus valores. Luego, se asigna dinámicamente una matriz a través de la función get_array, se accede a cada elemento de la matriz a través de la variable de puntero arr2 y se emiten sus valores. Finalmente, los valores de las variables a y b se intercambian a través de la función swap y se emiten sus valores. Tenga en cuenta que después de usar la matriz asignada dinámicamente, debe usar la función libre para liberar espacio en la memoria.
7. Resumen
Este artículo explica en detalle los conceptos relacionados y el uso de punteros en lenguaje C, incluida la definición, inicialización, operación y aplicación de punteros. Los punteros se usan ampliamente en el lenguaje C y se pueden usar para la asignación dinámica de memoria, el paso de parámetros de funciones, el acceso a matrices, etc. Al usar punteros, debe prestar atención a la inicialización de las variables de puntero, el tipo de datos al que apunta, los problemas de límites, etc. A través del estudio de este artículo, creo que los lectores tienen una comprensión más profunda de la capacidad de comprensión y aplicación del puntero.