Resumen de los puntos básicos de conocimiento del lenguaje C

1. Tipo de datos

char //字符数据类型 'A'
short //短整型
int   //整型
long  //长整型
long long //更长的整型
float      //单精度浮点数
double     //双精度浮点数

double d = 3.14;
printf("%lf\n", d);

unsigned char i ;//0~255
char i//-128~0~127

1. ¿Por qué hay tantos tipos?

printf("%d\n",sizeof(char));	//1
printf("%d\n",sizeof(short));	//2
printf("%d\n",sizeof(int));		//4
printf("%d\n",sizeof(long));	//4/8
printf("%d\n",sizeof(long long));//8
printf("%d\n",sizeof(float));	//4
printf("%d\n",sizeof(double));	//8

注：同一类型的有符号数和无符号数所占字节数相同

short int age = 20;  //2^16=65535

Es decir, para expresar más abundantemente varios valores en la vida.

método de almacenamiento de datos

Constantes y Variables

1 Alcance

Cuando una variable local y una variable global son iguales, la variable local tiene prioridad.

//取地址符号&
scanf("%d%d",&num1,&num2);
//避免编译器提示语法不安全
#define _CRT_SECURE_NO_WARNINGS 1

declarar extren símbolo externo

extern int g_val;
printf("g_val = %d\n", g_val);

2. El ciclo de vida de las variables

• El ciclo de vida de las variables locales: comienza el ciclo de vida de entrar en el alcance y termina el ciclo de vida de fuera del alcance.
• Ciclo de vida de las variables globales: el ciclo de vida de todo el programa

3. Constantes

• constante literal
• const variable constante modificada
• Constantes de identificador definidas por #define
• constante de enumeración

const int num = 4;
num = 8 //不能进行更改

int  n = 10;
int arr[n] = {
    
    0};//应该放入常量表达式

enum Sex
{
    
    
	MALE,
	FEMALE,
	SECRET
};
int main()
{
    
    
	printf("%d\n",MALE);	//0
	printf("%d\n",FEMALE);	//1
	printf("%d\n",SECRET);	//2
	enum Sex sex = MALE;
	sex = FEMALE;	//可更改
	FEMALE = 6;		//不能更改
}

cadena de matriz

int main()
{
    
    
	char arr1[] = "abc";
	//'a','b','c','\0'
	//'\0'：字符串的结束标志 
	char arr2[] = {
    
    'a','b','c'};
	char arr3[] = {
    
    'a','b','c','\0'};
	printf("%s\n",arr1); //abc
	printf("%s\n",arr2); //abc烫烫烫bc
	printf("%s\n",arr3); //abc
	printf("%d\n",strlen(arr1));//3
	printf("%d\n",strlen(arr2));//随机值
	
	printf("%d\n",strlen("c:\test\32\test.c"));//13
	//32是两个8进制数字，转化为10进制后ASCII码值所对应的字符
	char arr4[5] = {
    
    'a',98};
	printf("%d\n",sizeof(arr4));//2,所占字节大小
	printf("%d\n",sizeof(arr1));//4
}

1. Matriz bidimensional

int arr[][4] = {
    
    {
    
    1,2,3,4},{
    
    5,6,7,8}};
//列下标不能省略

El parámetro tiene la forma de una matriz.

El parámetro tiene la forma de un puntero.

*((*p+i)+j) =  (*(p+i)[ j ])

puntero

Almacena la dirección de la unidad de memoria, la unidad de memoria está en bytes
*–> operador de desreferencia
El tamaño del puntero es de 4 bytes en una plataforma de 32 bits

double d = 3.14;
double* pd = &d;
//sizeof(pd) = sizeof(double*)

指针类型决定了指针解引用操作的时候，能够访问空间的大小
int *p;//能够访问4个字节
char *p;//能够访问1个字节
指针类型决定了指针的步长
int *p; //p+1->4
cahr *p; //p+1->1
double *p; //p+1->8

1. Matriz de punteros

2. Puntero de matriz

3. Resumen

puntero avanzado

1. Puntero de función

2. Matriz de punteros de función

Puede reemplazar la declaración de cambio

3. Un puntero a una matriz de punteros de función.

función de clasificación

funciones de cadena

palabra clave (definición estática)

Modificación estática de variables locales: prolongar el ciclo de vida de las variables locales
Modificación estática de variables globales: reducir el alcance de las variables globales y se produce un error cuando otra función declara extern
Modificación estática de funciones: cambiar el atributo de enlace de la función , haciendo que los atributos del enlace externo se conviertan en atributos del enlace interno

definición de macros

#define MAX(X,Y) (X>Y?X:Y)
int main()
{
    
    
	max = MAX(a,b);//max = (a>b?a,b)
}

estructura

//结构体变量.成员
//结构体指针->成员
struct Book
{
    
    
	char name[20];
};
int main()
{
    
    
	struct Book b1 = {
    
    "CCC"};
	struct Book* pb = &b1;
	printf("%s\n",b1.name);
	printf("%s\n",(*pb).name);
	printf("%s\n",pb->name);
//更改成员数据
	b1.name = "uuuu"//err
	strcpy(b1.name,"uuuu");//string.h
}

ciclo

	int i = 1;
	while(i<10)
	{
    
    
		if(i == 5)
			continue;
		printf("%d",i);
		i++;
	}
	//陷入死循环，当i=5时，跳到while，然后到continue，还会回到while

	//ctrl+z 可结束
	while(ch = getchar()! = EOF)
	{
    
    
		putchar(ch);
	}
	char password[20] = {
    
    0};
	scanf("%s",password);
	ret = getchar();
	//当输入完后，按下回车键，‘\n’就会被ret接收
	while(ch=getchar()!='\n')
	{
    
    
		;
	}
	//将缓冲区读取完

La variable de control de bucle de la sentencia for:
1. No modifique la variable de bucle en el cuerpo del bucle for para evitar que pierda el control
2. Se recomienda que el valor de la variable de control de bucle de la sentencia for adoptar el método de escritura de "intervalo abierto después de cerrar antes"

	int i=0,k=0;
	for(i=0,k=0;k=0;i++)
		k++;
	//不进入循环，k=0为假

#include<windows.h>
Sleep(1000);
#include<stdlib.h>
system("cls");//清空屏幕
//时间戳
srand((unsigned int) time()); 
ret = rand()

función

1. Llamada de función

Una vez que se crea una instancia del parámetro formal, en realidad es equivalente a una copia temporal del parámetro real.

La llamada por dirección puede establecer una conexión real entre la función y las variables fuera de la función, es decir, el interior de la función puede manipular directamente las variables fuera de la función

La función printf devuelve el número de caracteres

2. Recursividad

1. Hay restricciones, cuando se cumple esta restricción, la recursividad no continuará

//计算字符串长度
//char arr[] = "bit";
//int len = my_strlen(arr);
int my_strlen(char *str)
{
    
    
	if(*str!='\0')
		return 1+my_strlen(str+1);
	else
		return 0;
}

3. Arreglos como parámetros de función

//arr是数组，对数组arr进行传参，实际上传递过去的是数组arr的首元素的地址 &arr[0]
buble_sort(arr,sr);

4. Punteros como parámetros

operador

1. Operadores aritméticos

Además del operador %, varios otros operadores trabajan con números enteros y de coma flotante.

2. Operador de turno

1. Desplazamiento aritmético a la derecha: descartar el lado derecho, rellenar el bit de signo original a la izquierda
2. Desplazamiento lógico a la derecha: rellenar cero a la izquierda

3. Operadores lógicos

^异或运算，相同为0，不同为1
！逻辑反操作
EOF：文件结束标志

取反

	int a = 0；//4个字节，32bit位
	int b = ~a;//b是有符号数的整形
	//存储的是补码，打印出的是原码，b=-1
	

memoria dinámica

#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main()
{
    
    
	//像内存申请10个整形的空间
	int* p = (int *)malloc(10*sizeof(int));
	if(p==NULL)
	{
    
    
		//打印错误原因的一个方式
		printf("%s",strerror(errno));
	}
	free(p)
	p=NULL;
	return 0;
}

matriz flexible

operación de archivo