1. En lenguaje C, puede usar la palabra clave const para modificar el puntero y limitar el acceso al espacio de memoria al que apunta el puntero .
int *const ptr3 = arr;
*ptr3 = 998;
ptr3 apunta a la matriz arr, el valor del elemento señalado por ptr3 se puede modificar, pero el elemento señalado por ptr3 no se puede modificar, por ejemplo: ptr = arr; ×
int const *ptr = &a; // Puntero de destino constante, solo se puede reemplazar pero no modificar el valor,
ptr=&b;
2. Forma cómoda de escribir el tipo de burbujas
for (i = 0; i < 3; ++i){ // Ordena la matriz usando la clasificación de burbujas
para (j = 0; j < 2 - i; ++j){
if (arr[j] > arr[j + 1])arr[j] ^= arr[j + 1] ^= arr[j] ^= arr[j + 1]；
}
}
3. Mida la longitud de la matriz.
int arreglo[10] = {1,2,3,4,5,6,7,8,9,10};
int sz = tamaño de (arr) / tamaño de (arr [0]);
4. Operadores bit a bit
Descartar a la izquierda, agregar 0 a la derecha;
int a = 2;
int b = a << 1; // Desplaza el bit binario de a 1 bit hacia la izquierda; b es 4,
a: 00000000000000000000000000000010
b : 0|000000000000000000000000000010+0
El lado derecho se descarta y el lado izquierdo se rellena con 0;
int a = 10;
int b = a >> 1;
a: 00000000000000000000000000001010
segundo: 0+0000000000000000000000000000101|0
5. Almacenamiento de números negativos
El número negativo -1 debe almacenarse en la memoria y la memoria se almacena en complemento a dos (255 - 1)
6. Operadores bit a bit
7. La diferencia entre los accesores a la estructura:
definición:
estudiante de estructura { nombre de char [20]; edad interna; };
estructura estudiante estu = {"Alicia", 18};
Operación de punto: (acceder a los miembros de la estructura a través de nombres de variables de estructura)
printf("Nombre: %s, Edad: %d\n", stu.nombre, stu.edad);
Operación de flecha: (acceder a los miembros de la estructura a través de punteros de estructura)
estudiante de estructura *pstu = &stu;
printf("Nombre: %s, Edad: %d\n", pstu->nombre, pstu->edad);
8. Suma y resta de punteros
Evite punteros salvajes, int* p = NULL; // Úselo cuando no sepa qué valor dar, incluso si asigna NULL
9. El papel de la resta de punteros
int arreglo[10] = {1,2,3,4,5,6,7,8,9,10};
printf("%d\n", &arr[9] - &arr[0]); // Obtiene el número de elementos entre el puntero y el puntero
10. Determine el tamaño del endian del sistema.
Porque cuando una máquina little endian almacena datos de varios bytes, el byte bajo viene primero y el byte alto le sigue, es decir, 0x01020304 se almacena como 0x04030201 en una máquina little endian. Si el byte bajo de a no es 1, significa que el orden de bytes de la máquina actual es big endian.
int a = 1;
char* pa = (char*)&a; // Aquí necesitas realizar una conversión de tipo forzada
if(*pa == 1)printf("little endian");
de lo contrario printf("big endian");
11. Tipo sin firmar sin firmar____
El rango de caracteres con signo es: -128 ~ 127
El rango de caracteres sin firmar es: 0 ~ 255
12. Almacenamiento de números de coma flotante.
El número binario de coma flotante V se puede expresar de la siguiente forma: (-1)^S * M * 2^E
① (-1)^s representa el bit de signo, cuando s = 0, V es un número positivo; cuando s = 1, v es un número negativo
② M representa un número válido, mayor o igual a 1, menor que 2
③ 2^E significa exponente
Ejemplo: Binario: 101,1 → 1,011 * 2^2 → (-1) ^0 * 1,011 * 2^2
Guardar como: s=0 M=1.011 E=2
13. Cómo escribir un puntero de matriz
for(i=0; i<10; i++)
{ //Las siguientes expresiones son todas equivalentes printf("%d ", p[i]); printf("%d ", *(p+i)); printf ( "%d ", *(arr+i)); printf("%d ", arr[i]); //arr[i] == *(arr+i) == *(p+i) = = p[yo] }
Matriz de punteros: int* parr1[10];
Puntero de matriz: int (*parr2)[10];
Matriz de punteros de matriz: int (*parr3[10])[5];
14. Paso de parámetros de matriz bidimensional
15. Puntero de función
int Agregar(int x, int y)return x + y；
int (*pf)(int, int) = &Add; //puntero de función
Matriz de punteros de función:
pfArr es una matriz de punteros de función y el interior de {} es el nombre de la función
int (*pfArr[5])(int, int) = {NULL, Agregar, Sub, Mul, Div};
usar:
entrada interna = 0;
for(input =1;input<5;input++) (pfArr[input])(x, y); //Ejecuta cada función por separado
16. Función de devolución de llamada del lenguaje C
void Calc(int (*pf)(int, int))
{ int x = 0; int y = 0; printf("Ingrese 2 operandos:>"); scanf("%d %d", &x, &y) ; printf("%d\n", pf(x, y)); }
Uso: En otras funciones: Calc(Add);//Add es una nueva función
17. Notas sobre el uso de punteros.
Si no está inicializado : int* p = NULL; // inicializado a NULL
Desreferenciación de punteros : antes de desreferenciar, es necesario asegurarse de que se haya asignado el bloque de memoria al que apunta el puntero.
si (p == NULL) {retorno 1;}
Libere el puntero después de su uso :
free(p); // libera el bloque de memoria
p = NULL; // asigna el puntero a NULL
Debe asegurarse de que los tipos de punteros coincidan :
int a = 10;
flotador b = 3,14;
int* p = &a; // puntero de tipo int apunta a la variable de tipo int
float* q = &b; // puntero de tipo float apunta a la variable de tipo float
18. Registro de operaciones en lenguaje C
Asigne un valor de 1 al bit 6 de un registro:
registro:
19. Definición de macro con parámetros
Para evitar verse afectado por la precedencia de llaves, punto y coma, operadores, etc.
20. Uso detallado de punteros.
1.
char ch = 'a';
char *p = &ch; ------->*p == p[0] ='a';
2.
char ch[] = {'a','\0'}; -----------ch es igual a &ch[0] ------->*ch==ch[0 ]= ='un'
3.
ent a;
int *p = &a;
a = 10;
*p = 9;
printf("a = %d\n", a); // la salida es 9
printf("&a = %d\n", &a); // Genera la dirección de a, es decir, la dirección de la variable a en la memoria
printf("p = %d\n", p); // Muestra el valor de p, es decir, la dirección de un
printf("p = %d\n", &p); // Genera la dirección de p, el resultado de salida es 4 en el sistema de 32 bits y el resultado de salida es 8 en el sistema de 64 bits
printf("*p = %d\n", *p); // Genera el valor señalado por p, es decir, el valor de a, y el resultado de salida es 9
4.
intb[5] = {1, 2, 3, 4, 5};
printf("b = %d ,*b = %d, *(b+1) = %d, *(b+2) = %d\n",b, *b, *(b+1), * (b+2));
//b = -13328 ,*b = 1, *(b+1) = 2, *(b+2) = 3
5. Modo de salida de matriz de cadenas
char *str = "Te amo";
int i, longitud;
longitud = strlen(cadena);
para (i = 0; i < longitud; i++)
{
printf("%c", cadena[i]);
}
//Te amo
6.
chararr[] = "abcdef";
char *p = arr;
printf("*p %c\n", *p); // a
printf("p %c\n", p[0]); // a B C D e F
printf("p %s\n", p); // a B C D e F
printf("arr %s\n", arr); // a B C D e F
printf("&p %d\n", &p); //-13312