2. Tipos de datos básicos y variables

1.Tipo de datos

Esta vez entendemos principalmente los tipos de datos básicos y los tipos booleanos.

Nota: [ ] significa que no puede omitir ni escribir
1,1 caracteres
char
[firmado] char
unsigned char

1.2 Entero
corto tipo entero
corto [int]
[con signo] corto [int]
sin signo corto [int]

整型
int
[firmado] int
unsigned int

⻓整型
long [int]
[firmado] long [int]
sin firmar long [int]

Tipos de enteros más largos (introducidos en C99)
long long [int]
[signed] long long [int]
unsigned long long [int]

1.3 Tipo de punto flotante
float Tipo de punto flotante de precisión simple
doble Tipo de punto flotante de precisión doble
largo doble

1.4 Tipo booleano (introducido desde C99)
1. El tipo booleano está representado por _Bool
2. El uso del tipo booleano requiere hacer referencia al archivo de encabezado <stdbool.h>
3. El valor de la variable de tipo booleano es verdadero o falso

//布尔类型
#include <stdio.h>
#include <stdbool.h>
int main() {
    
    
	_Bool flag = true;
	if (flag) {
    
    
		printf("i'm true");
	}
	else{
    
    
		printf("i'm false");
	}
	return 0;
}

2.firmado y sin firmar

El lenguaje C utiliza palabras clave con y sin signo para modificar tipos de caracteres y enteros.
La palabra clave con signo indica que un tipo tiene un signo y contiene valores negativos; la
palabra clave sin signo indica que el tipo no tiene un signo y solo puede representar cero y números enteros positivos (no negativos).

Por lo tanto, al introducir los tipos de datos anteriores, si se requiere que el tipo de datos represente solo números enteros no negativos, se debe modificar con la palabra clave unsigned; de lo contrario, se puede modificar con la palabra clave con signo, pero la mayoría de los rangos de tipos de datos incluyen valores positivos. Negativo, por lo que básicamente se puede omitir el signo.

ejemplo:

//定义整型变量a
signed int a;
int a;//signed可以省略

//定义非负整型变量a
unsigned int a;

Tomando el tipo entero int como ejemplo, ¿cuáles son los beneficios de declarar una variable int sin signo?
La ventaja es que el valor entero máximo que puede representarse con la misma longitud de memoria es el doble.
Por ejemplo:
el rango de valores de int corto con signo de 16 bits es: -32768~32767, el valor máximo es 32767;
mientras que el rango de valores de int corto sin signo es: 0~65535, el valor máximo es 65535

3. Rango de valores del tipo de datos

El archivo limites.h describe el rango de valores del tipo entero y
el archivo float.h describe el rango de valores del tipo de punto flotante.

Tamaño de almacenamiento y rango de valores de tipos de números enteros

Tamaño de almacenamiento y rango de valores de tipos de punto flotante

Constantes SCHAR_MIN y SCHAR_MAX para los valores límite del rango de valores de tipo entero : los valores mínimo y máximo de char con signo.
SHRT_MIN, SHRT_MAX: los valores mínimo y máximo de short.
INT_MIN, INT_MAX: el valor mínimo y máximo de int.
LONG_MIN, LONG_MAX: los valores mínimo y máximo de long.
LLONG_MIN, LLONG_MAX: los valores mínimo y máximo de long long.
UCHAR_MAX: el valor máximo de carácter sin firmar.
USHRT_MAX: el valor máximo de corto sin firmar.
UINT_MAX: el valor máximo de int sin signo.
ULONG_MAX: el valor máximo de largo sin firmar.
ULLONG_MAX: el valor máximo de largo sin firmar.

demostración de código

#include <limits.h>
int main() {
    
    
//存储大小
	printf("char的存储大小：%d\n",sizeof(char));
	printf("short的存储大小：%d\n", sizeof(short));
	printf("int的存储大小：%d\n", sizeof(int));
	printf("long的存储大小：%d\n", sizeof(long));

	//short int和long int 就是 short和long 这定义类型可以省略int 
	printf("short int的存储大小：%d\n", sizeof(short int));
	printf("long int的存储大小：%d\n", sizeof(long int));

	printf("long long的存储大小：%d\n", sizeof(long long));
	printf("unsigned char的存储大小：%d\n",sizeof(unsigned char));
	printf("unsigned short的存储大小：%d\n",sizeof(unsigned short));
	printf("unsigned int的存储大小：%d\n",sizeof(unsigned int));
	printf("unsigned long的存储大小：%d\n",sizeof(unsigned long));
	printf("unsigned long long的存储大小：%d\n",sizeof(unsigned long long));

	printf("float的存储大小：%d\n", sizeof(float));
	printf("double的存储大小：%d\n", sizeof(double));
	printf("long double的存储大小：%d\n", sizeof(long double));//long double字节大小至少8字节，不同编译器得出的结果不同，但肯定大于等于double的8字节

	printf("--------------------------------------------\n");
	
//取值范围
	printf("char的取值范围：%d %d\n", SCHAR_MIN, SCHAR_MAX);
	printf("unsigned char的取值范围：%d\n", UCHAR_MAX);	

	printf("short的取值范围：%d %d\n", SHRT_MIN, SHRT_MAX);
	printf("unsigned short的取值范围：%d\n", USHRT_MAX);

	//%d 十进制有符号整数   
	printf("int的取值范围：%d %d\n", INT_MIN, INT_MAX);
	//%u （16位）十进制无符号整数(unsigned int的最大存储范围已经超出了%d所能表示的范围)
	printf("unsigned int的取值范围：%u\n", UINT_MAX);

	//%d=int  %ld=long  %lld=long long（long和long long的取值范围都已经超出了int的范围 所以对应的格式化占位符也要修改 否则会出错

	//%ld [32位]长整型数据类型
	printf("long的取值范围：%ld %ld\n", LONG_MIN, LONG_MAX);
	//%lu [32位]无符号长整型数据类型
	printf("unsigned long的取值范围：%lu\n", ULONG_MAX);

	//%lld 64位长整型数据类型
	printf("long long的取值范围：%lld %lld\n", LLONG_MIN, LLONG_MAX);
	//%llu 64位无符号长整型数据类型
	printf("unsigned long long的取值范围：%llu\n", ULLONG_MAX);

	return 0;
}

4.Variables

Las variables son valores que se pueden cambiar en lenguaje C. Al crear una variable, debe definir un tipo de datos para la variable.

Las constantes son valores que no cambian en el lenguaje C. Por ejemplo, el rango de valores del tipo entero mencionado anteriormente es
INT_MIN, e INT_MAX representa el rango de valores mínimo y máximo del tipo int. Estos dos son constantes.

Definir variables
es muy simple, tipo de datos + nombre de variable (el nombre de la variable no debe entrar en conflicto con las palabras clave)

char a;//字符变量
int b;//整型变量
float c;//浮点型变量

Inicializar una variable.
Darle un valor inicial cuando se crea la variable.
El valor inicial debe corresponder al tipo de datos.

int a = 1;
char b = '1'
float c = 1.1;

No inicializar variables.Variables
enteras (int, short, long, etc.): el valor predeterminado es 0.
Variables de punto flotante (flotante, doble, etc.): el valor predeterminado es 0,0.
Variable de carácter (char): el valor predeterminado es '\0', que es el carácter nulo.

5. Variables globales y variables locales

Variables globales: las variables definidas fuera de las llaves son variables globales. Las variables globales
tienen una amplia gama de influencia, involucran todo el proyecto y se puede hacer referencia a ellas en cualquier lugar.

Variables locales: las variables definidas dentro de llaves son variables locales.
Las variables locales solo pueden afectar el alcance local y generalmente se puede hacer referencia a ellas dentro de sus propias llaves.

#include <stdbool.h>
//全局变量和局部变量
int global = 1;//全局变量
int main() {
    
    
	int local = 2;//局部变量
	if (true){
    
    
		int local_in = 3;//局部变量
		printf("局部变量：%d\n", local_in)//这里就可以调用local_in局部变量
	}

	printf("全局变量：%d\n", global);
	printf("局部变量：%d\n", local);
	//printf("局部变量：%d\n", local_in); //无法调用局部变量local_in，报错
}

Si la variable local que se llama está definida entre llaves y es más interna que el punto de llamada, no se puede llamar a la variable local. Tomando el
int local_in = 3 anterior como ejemplo, cuando se llama a local_in mediante impresión externa, la definición de local_in que es más interno que él mismo no se puede encontrar, por lo que la llamada falla y se informa un error.

Si la variable local y la variable global tienen el mismo nombre de variable

#include <stdbool.h>
//全局变量和局部变量
int global = 1;//全局变量
int main() {
    
    
	int global = 2;//局部变量
	printf("全局变量：%d\n", global);
}

Resultado de la depuración

Motivo: la variable local interna sobrescribe el valor de la variable global. (La sobrescritura aquí no se refiere a modificar el int global = 1 de la variable global, sino a sobrescribir el valor global en el paso de impresión y los valores definidos originalmente permanecen sin cambios)

Dónde se almacenan las variables locales y las variables globales en la memoria (comprender)
1. Las variables locales se almacenan en el área de pila de la memoria
2. Las variables globales se almacenan en el área estática de la memoria

6. Operadores aritméticos (+, -, *, /, %)

**+ - * / % **Estos operadores aritméticos son todos operadores binarios.
Nota: Operador binario significa que el operador tiene dos operandos, es decir, hay un número en cada extremo del operador.

//算数运算符
int main() {
    
    
	//加 减 乘（+ - *）
	int a = 1, b = 2, c = 3;
	int add = a + b + c;
	int sub = c - b - a;
	int mul = a * b * c;
	printf("add=%d  sub=%d  mul=%d\n", add, sub, mul);

	return 0;
}

La suma, la resta y la multiplicación son muy regulares. ¡Hablemos de la división por separado! ! !

int main() {
    
    
	// 除（/）
	int a = 1, b = 2, c = 3;
	float bf = 2, cf = 3;

	int div_i = c / b;
	float div_f1 = c / b;
	float div_f2= cf / bf;

	printf("div_i=%d\n", div_i);//1
	printf("div_f1=%f\n", div_f1);//1.000000
	printf("div_f2=%f\n", div_f2);//1.500000

	return 0;
}

Aparecen tres resultados diferentes que se discuten uno por uno.
Consejo: La división de enteros en lenguaje C es una división de enteros, solo devolverá la parte entera y descartará la parte decimal.

1. printf(“div_i=%d\n”, div_i);//1
fórmula int div_i = c / b El tipo de variable de resultado div_i es int, y los operandos cyb en ambos extremos del operador son ambos de tipo int
El proceso es:
dividir dos variables int c y b, el resultado es 1, asignarlo a la variable div_i
y como div_i es de tipo int, entonces div_i=1
y luego usar el marcador de posición %d para generar e imprimir

2. printf(“div_f1=%f\n”, div_f1);//1.000000
fórmula float div_f1 = c / b La variable de resultado div_f1 es de tipo flotante y los operandos cyb en ambos extremos del operador son de tipo int
El proceso es:
dividir dos variables int c y b, el resultado es 1, asignarlo a la variable div_f1
y debido a que div_f1 es de tipo flotante, entonces div_f1=1.000000
y luego usar el marcador de posición %f para generar e imprimir

3. printf(“div_f2=%f\n”, div_f2);//1.500000
fórmula float div_f1 = cf / bf El tipo de variable de resultado div_f2 es flotante, y los operandos cyb en ambos extremos del operador son ambos de tipo flotante
Nota: Las variables aquí son divisiones de tipo flotante ( siempre que al menos una variable flotante participe en la operación, el lenguaje C realizará una división de punto flotante ). Si se dividen números de punto flotante, la división no será una división de números enteros.
Según el proceso:
divida dos variables flotantes cyb, el resultado es 1.500000, asígnelo a la variable div_f2
porque div_f2 es un tipo flotante, por lo que div_f2 = 1.500000
y luego use el marcador de posición %f para generar e imprimir

El operador % representa la operación de módulo, que devuelve el resto de la división de dos números enteros.
(Este operador sólo se puede utilizar con números enteros, no con números de coma flotante)

//取模%
int main() {
    
    
	int b = 2, c = 3;
	int mod = c % b;
	printf("mod=%d", mod);//1
	return 0;
}

La regla para los números de módulo negativo es que el signo del resultado está determinado por el signo del primer operando.

int main() {
    
    
	printf("%d\n", 11 % -5); // 1
	printf("%d\n", -11 % -5); // -1
	printf("%d\n", -11 % 5); // -1
	return 0;
}

7. Operador de asignación (=)

Cuando se crea una variable, se inicializa un valor inicial. Una vez creada la variable, la asignación de un valor se denomina asignación.

//赋值运算符
int main() {
    
    
	int a = 100;//初始化
	a = 101;//赋值
	return 0;
}

asignación continua

//连续赋值
int main() {
    
    
	int a = 100;//初始化
	int b = 101;//初始化
	int c = 102;//初始化
	a = b = c + 98;//不推荐变量连接成一块，看着费劲
	
	//建议分开写，方便观察读写
	b = c + 98;
	a = b;
	printf("a=%d b=%d c=%d",a,b,c);//从右向左依次赋值的 200 200 102
	
	return 0;
}

Valores asignados de derecha a izquierda

operador de asignación compuesta

//复合赋值
int main() {
    
    
	int a = 100;
	int b = 100;
	a += 3;//等同于 a = a + 3
	b -= 3;//等同于 b = b - 3

	printf("a=%d\n", a);//103
	printf("b=%d\n", b);//97

	return 0;
}

Operadores de asignación compuesta de uso común

*=	/=	%=	/=	%=
>>=	<<=	&=	|=	^=

8. Operadores unarios (++, –, + (positivo), - (negativo))

Los operadores ++, - -, + (positivo) y - (negativo) tienen un solo operando, por lo que son operadores unarios.

+ (Positivo) - (Negativo)
No introduciré demasiado sobre los signos positivos y negativos. Son positivos y negativos en matemáticas. El
signo positivo (+) básicamente se puede omitir. Puedes escribirlo o no.
El negativo El signo (-) simplemente hace que el número sea negativo. También es una verdad muy simple, pero no la presentaré en demasiado detalle.

++ y - -
++ aumentan, - - disminuyen. La función de ++ es hacer que la variable sea +1, y la función de - - es hacer que la variable -1.
++ y - - se pueden colocar antes o después del operando. El posposicionamiento y el posposicionamiento harán que el orden de +1 sea diferente.

ejemplo

int main() {
    
    
	int a = 1;
	int b = a++;
	printf("b=%d\n", b);//b=1
	printf("a=%d", a);//a=2
	return 0;
}

El ejemplo anterior es un incremento automático seguido de
int b = a++. Primero asigna a=1 a b, entonces b=1
y luego incrementa automáticamente a++ (equivalente a a = a+1), entonces a=2

int main() {
    
    
	int a = 1;
	int b = ++a;
	printf("b=%d\n", b);//b=2
	printf("a=%d", a);//a=2
	return 0;
}

El ejemplo anterior es un prefijo de incremento automático
int b = ++a. Primero, incrementa automáticamente a++ (equivalente a a = a+1), entonces a=2
y luego asigna a=2 a b, entonces b=2

De la misma forma, se pueden obtener el prefijo y el sufijo de autodecremento, por lo que no daré un ejemplo ^ _ ^

9. Conversión de tipo forzada

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

Aparecerá una advertencia y algunos compiladores informarán un error directamente. La conversión de números de punto flotante a enteros sacrificará la precisión y perderá la parte decimal de los datos.

Para eliminar la advertencia, debe utilizar la conversión de tipo forzada y agregar (tipo) antes del valor o tipo que debe convertirse.

//强制类型转换
int main() {
    
    
	int a = (int)3.14;//浮点数前加上  (强制转换的类型)
	printf("a=%d", a);
	return 0;
}

Se ejecuta correctamente sin errores ni advertencias, pero aun así pierde precisión.