Conocimientos básicos de matrices
char arr [] = {0}; //
char correcto arr [] = ""; // correcto
char arr [10] = "";
char arr [10]; // correcto
char arr []; //
resumen del error : Si desea expresar la matriz correctamente
1. Inicialice la matriz para dar o no dar el tamaño
2. Si no está inicializada, debe dar el tamaño de la matriz
~: El número es la inversión bit a bit de un valor
~ 0 (tipo int 4 bytes 32 Bits)
= ~ 00000000000000000000000000000000
= 11111111111111111111111111111111
= -1
// El número complejo se almacena en la memoria como complemento binario, el bit más alto es el bit de signo, 0 es positivo y 1 es negativo,
y se imprime el código original de este número. La
fórmula de cálculo: original El bit de signo de código permanece sin cambios y el resto se invierte por bit para obtener el código inverso, el código inverso +1 se convierte en el código de complemento,
porque almacenar como código de complemento solo necesita el proceso anterior para invertir la secuencia para obtener el código original y finalmente imprimirlo
11111111111111111111111111111111 (código de complemento) -1
= 1111111111111111111111111111 Código inverso) El bit de signo no cambia y los bits restantes se invierten en bit
= 1000000000000000000000000001 (código original)
= -1 (resultado de salida)
Ejemplo:
~ 5
= ~ 000000000000000000000000000000000101
= 11111111111111111111111111111010 (código de complemento)
= 11111111111111111111111111111001 (código inverso)
= 10000000000000000000000000000110 (código original)
= -6
++ y -:
++ i (primero +) ++ i (último agregado)
#include <stdio.h>
int main () {
int i = 0;
printf ("% d \ n", i); // 0
printf ("% d \ n", ++ i); // 1
printf ("% d \ n" , i); // 1
printf ("% d \ n", i ++); // 1
printf ("% d \ n", i); // 2
return 0;
}
Forzar conversión de tipo:
int i = (int ) 3.14; // Ser el mismo antes y después del tipo
&& || y & | Diferencia:
&& y || son símbolos lógicos:
3 && 2 = 1;
0 && 2 = 0;
3 || 2 = 1;
3 || 0 = 1;
& y | Para calcular el símbolo:
3 & 2 = 0011 & 0010 = 0010 = 2
Operador ternario :
(1)? (2) :( 3) // Si (1) es verdadero entonces (2) si (1) es falso entonces (3)
num = (1 <2)? 1: 2; // num es 1
Por ejemplo:
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main ()
{
int a = 2;
(a == 2)? (A = 4 ):(a = 10);
printf ("% d \ n", a); // La salida es 4
return 0;
}
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main ()
{
int a = 3;
(a == 2)? (a = 4): (a = 10);
printf ("% d \ n", a); // 输出 为 10
return 0;
}
registrar palabra clave
Uso:
register int a = 10; // Se recomienda definir a como una variable de registro (la velocidad de ejecución del registro es mucho más rápida que la memoria). Se recomienda elegir debido al espacio de registro limitado
palabra clave typedef (definición de tipo / redefinición de tipo)
Por ejemplo, defina una variable entera sin signo:
unsigned int num = 10;
pero unsigned int parece demasiado largo, demasiado problemático, puede usar typedef para redefinir el
uso:
typedef unsigned int u_int; // Esto convertirá unsigned int en u_int
unsigned int num = 10; equivalente a u_int num = 10;
Nota: la
palabra recién definida debe ser una palabra u_int no puede ser u int (dos palabras)
palabra clave estática
Hacer una variable o función estática
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void test () {
int a = 10;
++ a;
printf ("% d \ n", a);
}
int main ()
{
int i = 0;
while (i <5) {
test ();
++ i;
}
return 0;
} El
resultado es cinco 11
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void test () {
static int a = 10;
++ a;
printf ("% d \ n", a);
}
int main ()
{
int i = 0;
while (i <5) {
test ();
++ i;
}
return 0;
}
El resultado es 11 12 13 14 15
Conclusión: cuando la estática modifica las variables locales, el ciclo de la variable se hace más largo
Es decir, el valor de esta variable no se reinicializará cuando se llame aquí a la función.
función externa
Uso:
extern int a; // a es una variable global de otros archivos .c (static modifica variables globales)
pero si a es static int a = 10 en este momento; entonces la función principal en otros archivos no puede ser externa (heredada) a esta externa variable.
Las funciones estáticas modificadas son las mismas que las variables.
extern declara la función externa:
extern int hanshu (int, int); // La declara donde sea que esté, siempre que sea llamada dentro o fuera de main.
define define constantes y macros
#define MAX 100 (constante)
#define MAX (X, Y) ((X> Y)? X: Y) (macro) // MAX (X, Y) es equivalente a la siguiente expresión trinocular y no Necesita especificar el tipo de parámetro