[Lenguaje C] Explicar en profundidad y simple, lo llevará a construir el marco macro del lenguaje C

Introducción:
este artículo le brindará una comprensión básica del lenguaje C, una comprensión perceptiva del mismo, un marco para él y complementos más detallados más adelante.

---

---

lenguaje C

¿Qué es el lenguaje C?

El lenguaje C es el lenguaje para la comunicación entre humanos y máquinas. Los primeros humanos se comunicaban con las computadoras usando un sistema binario (investigadores científicos) y luego un ensamblaje simplificado (algunos geeks), luego el lenguaje B, el lenguaje C (popular) y luego ahora C++/java ..., el lenguaje C es un lenguaje de programación que se comunica con las computadoras para realizar sus ideas

primera función

En lenguaje C/C++, el siguiente código aparecerá por defecto al crear un proyecto en el IDE (Integrated Development Environment)

int main()
{
    
    
	return 0;
}
//或者是
int main(int argc,char *argv[])
{
    
    
	return 0;
}
//这里的argc 和  argv是命令行参数，argc是有多少个指令 argv就是指令啦，挖坑。

Algunas personas pueden tener tales dudas cuando lo ven por primera vez: ¿Qué es esto? ¿Cual es el uso? ¿Puedo comerlo? 3 preguntas consecutivas. Menos mal que me conociste, explícalo de la siguiente manera:

La función principal es el punto de entrada del programa, que es la única forma de ejecutarlo. Puedes pensar que es así, 但是他还有许多的坑或者说细节：一个项目中只能有一个main函数，一个项目只能有一个main函数，一个项目只能有一个main函数重要的事情说三次¿y si escribes más de uno?

那当然是报错喽，运行不起来。

Introduce las siguientes funciones:

variable

Las variables simplemente se utilizan para almacenar datos y hay más de un tipo de variable, incluidos los tipos integrados y los tipos personalizados. Entonces puede preguntar por qué se necesita el tipo,如果抽象成现实生活中事情，那就是买房子，每个人的需求不一样买的房子也不一样，但是造房子有对应的户型，当然是你也可以买地皮自己造.......当然计算机也是创建变量本质也就是向内存申请空间

//内置类型 
	// sort(短整型)、int(整型)、long(长整型)、long long(长长整型) 、char(字符型)、float(单精度浮点型)、double(双精度浮点型)
//sizeof是一个关键字，也是一个操作符,计算变量的大小(字节)
printf("%d",sizeof(short)) //sort 和short int  result: 2字节
printf("%d",sizeof(int)) // result:4
printf("%d",sizeof(long)) // result:4 
printf("%d",sizeof(long long)) //result:8 
printf("%d",sizeof(char)) //result:1
printf("%d",sizeof(float)) //result:4
printf("%d",sizeof(double)) //result:8


//自定义类型
	//struct 所定义的变量，现在感性理解他就是内置类型的集合体
	//union 联合体
	//变量类型大小涉及到特殊存储规则，挖坑

Algunas personas pueden preguntar por qué se usan bytes. ¿Qué son los bytes?

Como se muestra en la figura, la unidad y la conversión de la computadora:

entonces, ¿por qué es un byte?
Debido a que la computadora solo reconoce la secuencia binaria de 0101, el almacenamiento de datos también se almacena en la memoria en binario, por lo que, como se muestra en la figura anterior, por supuesto, es mejor usar bytes. Si desea un área de pila (donde las byte少了kb又太多variables , etc. están almacenados) es solo 4mb (Mira el sistema operativo), si kb, la mayoría de los proyectos no son suficientes para crear variables ~


expanda la tabla ASCII

Variables locales frente a variables globales

Comprensión simple, mire el alcance (es decir, el alcance en el que se pueden usar las variables) o el ciclo de vida (es decir, el alcance desde la creación hasta la destrucción de variables) de la siguiente manera

int global; //全局变量
int main()
{
    
    
	int local;//局部变量 
	return 0;
}

//全局变量：从创建到程序结束才释放
//局部变量：从创建到花括号/大括号({})结束,但是可以用static修饰导致他出了作用域爷不会销毁，挖坑

ejemplo/característica interesante

#include<stdio.h>

int a =1;
int main()
{
    
    
	int a = 2;
	printf("%d",a);
	return 0;
}

¿Cuál crees que es la respuesta: (1, 2)?
Si eligió 2, entonces felicidades, eligió el correcto, entonces, ¿por qué? Ya que preguntaste con sinceridad, te lo diré misericordiosamente. 这个就是局部优先的原则，全局变量和局部变量重名时局部优先。Pero no recomiendo que escriba dicho código en tiempos normales, pero esto aparecerá en el título, solo échele un vistazo.

constante

Como sugiere el nombre, no se puede cambiar después de la creación. Si se cambia, se informará un error. En lenguaje C, existen las siguientes formas de crear

#include<stdio.h>
int main()
{
    
    
	//1.字面常量
	10;
	//2. const所修饰的常变量，后面和指针数组结合会有奇怪的化学反应
	const int a;  int const a; //俩者一致
	//3. 宏定于的标识符常量
	#define MAX 100;
	return 0;
	//4.枚举类型就是一一可以列举的值，可以理解给数字起名字,如下代码Read默认从0开始后面依次递增,也可以赋值赋值后已赋的常量为起点依次递增
	enum 类型
	{
    
    
		Read,
		Green,
		Blue	
	}	
}

No se si tienes una duda, es decir todo lo demas es una constante, por que la const modificada se llama variable constante?

//在C11标准之前创建数组只可以用常量，数组就是同类元素的集合
const int count = 10;
int arr[count]; //这样就会报错

Cadenas y caracteres de escape

Una cadena es una cadena de varios caracteres encerrados por un par de comillas dobles (“ ”)y la representación de terminación de la cadena es \0, como sigue
Validación del administrador de recursos:

verificar con código

Se puede ver por sizeof que a2 tiene un elemento más que a1, pero se puede ver que la longitud de la cadena a2 de strlen es mucho más larga que a1, y strlen también termina en \0, si no hay, siempre se verá para \0

carácter de escape :

archivo principal

Me pregunto si alguna vez ha pensado por qué necesita citar los archivos de encabezado cuando usa printf y scanf (funciones de biblioteca de entrada y salida).

La función de biblioteca se usa con mucha frecuencia, por lo que la implementación oficial es conveniente para nosotros.
¿Por qué necesita citar el archivo de encabezado, porque cuando compila, todo el código (funciones de biblioteca) contenido en el archivo de encabezado se copiará automáticamente en el archivo actual?

expandir

// 当你使用函数的时候是从上往下查找的后实现的代码写到下面去如下所示
int add(int x , int y);

int main()
{
    
    	
	prinft("%d",add(10,20));
}
int add(int x , int y)
{
    
    
	return x+y;
}

ramificación y bucle

En nuestra vida diaria, hemos estado eligiendo y repitiendo algo. Por supuesto, en programación, la selección es bifurcación y la repetición es bucle. Usa el siguiente código

// 分支
	//单分支 if/else if/ else
	//多分支 switch
if(条件)//条件真则执行语句1
	语句1;
else//条件假执行语句2
	语句2;

if(条件1)//条件1真则执行语句1
	语句1;
else if(条件2)//条件1假且条件2真则执行语句2
	语句2;
else//条件1且条件2都是假则执行语句3
	语句3;

//当switch的值和case值一样时则执行对应的语句，如果都不满足且有default则执行default中的语句
switch(值)
{
    
    
	case 值1:
		语句1;
	case 值2:
		语句2;		
	case 值3:
		语句3;
	default:
		语句4;
}
//循环
	//while
	while(条件) //当条件满足时会一直循环执行语句不满足时候则退出循环
	{
    
    
		语句;
	}
	//for：一般用于已经知道循环多少次
	for(变量;条件;退出条件)
	{
    
    
		语句;
	}
	do
	{
    
    
		语句;
	}while)(条件); //do while无论条件是否满足都会执行语句 

Palabras clave que se pueden usar tanto con bucles como con ramas:

1. continuar La ejecución de esta sentencia saltará este ciclo, es decir, no se ejecutará el siguiente código
2. romper saltar fuera del bucle directamente

int main()
{
    
    
	for(int i=0;i<10;i++)
	{
    
    
		if(i ==5)
		{
    
    
			continue;
		}
		printf("%d ",i);
	}
	//result:0 1 2 3 4 6 7 8 9


	for(int i=0;i<10;i++)
	{
    
    
		if(i ==5)
		{
    
    
			break;
		}
		printf("%d ",i);
	}
	//result:0 1 2 3 4	
}

nota

Hay un acecho en aprender a programar, odio escribir comentarios y otros no escribir comentarios. Entonces, ¿cuál es el uso de los comentarios? Es ayudarlo a usted y a otros a comprender el código. Cómo comentar en lenguaje C

1. //
2. /**/, no se recomienda este método porque no se puede anidar

/**/ Técnica práctica: cuando implementa una función y hay muchos parámetros, puede anotar los parámetros de esta manera:

int add(int x/*参数1*/,int y /*参数2*/)
{
    
    return x+y;}
int main()
{
    
    
	add(10,20);
}

formación

Un conjunto de variables del mismo tipo, la sintaxis es la siguiente

// 类型 + 数组名 + [数组变量个数]  = {数据}
int arr[10];

Sintaxis especial: el número de definiciones de creación de matriz en versiones anteriores a C11 一定要是常量，不puede ser una variable, pero debe ser una constante

¿Cómo acceder y poner variables en variables?

//[]（下标访问操作符） 或者 *数组名+值
//注意，下标是从0开始的一定要记住，不然就越界访问了
int arr [10];
for(int i =0;i<=10;i++)
{
    
    
	arr[i] = i;
	printf("%d ",arr[i]);//result:0 1 2 3 4 5 6 7 8 9
}

for(int i =0;i<=10;i++)
{
    
    
	printf("%d ",arr+i);
}

palabras clave

Hay muchas palabras clave en el lenguaje C, que son caracteres que están dotados de funciones especiales, como las siguientes:

El papel de la estática

1. Modificar variables locales

//static 会改变局部变量的生命周期
int fun1()
{
    
    
	int a = 0;
	a++;
	printf("%d ",a);
}

int fun2()
{
    
    
	static int a = 0;
	a++;
	printf("%d ",a);
}

int main()
{
    
    
	for(int i =0;i<3;i++)
		fun();
}
//result fun1: 1 1 1
//result fun2: 1 2 3

2. La declaración de variables y funciones globales
   solo se puede usar en este archivo .c después de la declaración. Generalmente, en el mismo archivo de proyecto, se pueden usar otros archivos .c siempre que estén declarados (externos)
   

Pero tal vez habrá tal escena, 在多人开发时A1写了个add的函数但是他的功能是俩数相加在加1，A2后面在开发别的功能想要用add函数但是他想要的就是简单的俩数相加，他偷懒声明看看有没有如果有entonces esto causará un gran problema, por lo que modificar la estática puede evitar tal oolong.

operador

//算数操作符
	printf("加：%d",1+2); //3
	printf("减：%d",1-2); //-1
	printf("乘：%d",1*2);//2
	printf("除：%d",1/2);//0
	printf("取模：%d",1%2);//1，取余数
//除法在这里是向下取整，并不是小数，但是只要除数和被除数其中一个是小数则结果也是小数
//取模俩边一定是整数不然会报错



//移位操作符（移动的是存储的二进制位，如上所述每个值在底层存储都是以二进制存储的,然后其实简单理解就是二进制位向左/右移动）
	printf("左移：%d",1<<2); //2
	printf("右移：%d",1>>2); //0
//8进制位例子
	00000001 >> 1 = 00000000	
	
	
//位操作符
printf("加：%d",1&1);// 1,对应的二进制位都是1时则保留，其余都为0
printf("加：%d",1|0); //1，对应的二进制位只要一个是1就为1
printf("加：%d",1&0); //0，对应的二进制位不同时则保留
//8进制位例子
	00000001			   | 00000001
		&	--->000000000  |		&    --->00000000
	00000001			   | 00000000		


//单目操作符
printf("! %d",!0001); // 0 ,逻辑反,非零数值变零，零变1
printf("sizeof %d",sizeof(int)); // 4,计算大小，也就是字节数
printf("前后置++/-- %d",++1); //2 就是自增或者自减，后置则为 1 先输出在加减
printf("～%d" ,~0001);//-2,全部二进制位取反
int a =10;
printf("& %p",&a);//0xadada 取地址，取出a在内存中的地址/编号 
printf("* %d",*(&a)); //10 解饮用，就是拿着地址去找对应的值



//逻辑操作符
printf("&& 与 %d",1&&1); // 1 ,逻辑与，操作符俩边都要是真的则为真
printf("|| 或 %d",1||0); //0 ,逻辑或，操作符俩边只要一个是真的则为真


//条件操作符/三目操作符
printf("%d",1>2?1:2); // 2 ,语法格式 a>b:a:b a>b真则为a反之b

macro

De hecho, es una función definida por #define, que suele ser una función corta.

#define ADD(X,Y) X+Y
int add(int x,int y)
{
    
    
	return x+y;
}
int main()
{
    
    
	printf("%d",add(1,1)); // 2
	printf("%d",ADD(1,1));// 2
}

Aunque sus resultados son los mismos, pero la macro es más eficiente, ¿por qué?

puntero

Expansión: memoria (comprensión simple)

Como se mencionó anteriormente, crear una variable es solicitar un espacio en la memoria, entonces, ¿cómo desea encontrar su variable en la memoria?

Eso es dividir la memoria en áreas de 1 byte y numerarlas, al igual que el número de casa de una casa.

¿Cómo crear y usar un puntero?

//类型 * 变量名
int a =10;
int *pa = &a;// pa此时存的就是a的地址

printf("%d",*pa);//用解引用操作符则可以找到a的值

Entonces, ¿cuál es el tamaño de un puntero?

printf("%d",sizeof(int *));
printf("%d",sizeof(char *));
printf("%d",sizeof(short *));
//结果都是4

¿Por qué los resultados son los 4 bytes?

Esto está relacionado con la cantidad de dígitos en la computadora. Si tiene una computadora de 32 bits, la computadora tiene 32 direcciones. Cuando se enciende cada línea de dirección, producirá un resultado de 0/1. Si se usan 32 bits para representar la dirección, son exactamente 4 palabras Sección, los 64 bits correspondientes son 8 bytes