Tabla de contenido
【2】 Interpretación del primer programa C
【4.2】Clasificación de variables
【4.4】Alcance y ciclo de vida de las variables
【13.1】Def. de tipo de palabra clave
【13.2.1】Modificar variables locales
【13.2.2】Modificar variables globales
【13.2.3】Función de modificación
【14】 Definir constantes y macros #definir
【15.2】El tamaño de las variables de puntero
【1】 ¿Qué es el lenguaje C?
El lenguaje C es un lenguaje de programación de computadoras general que se usa ampliamente en el desarrollo de bajo nivel. El objetivo de diseño del lenguaje C es proporcionar un lenguaje de programación que pueda compilarse fácilmente, manejar memoria de bajo nivel, generar una pequeña cantidad de código de máquina y que pueda ejecutarse sin ningún soporte de entorno de ejecución.
Aunque el lenguaje C proporciona muchas funciones de procesamiento de bajo nivel, aún mantiene buenas características multiplataforma. Un programa en lenguaje C escrito en una especificación estándar se puede compilar en muchas plataformas informáticas, incluso incluyendo algunos procesadores integrados (microcontroladores o (llamados MCU) y supercomputadoras y otras plataformas operativas.
En la década de 1980, para evitar diferencias en la sintaxis del lenguaje C utilizada por varios desarrolladores, la Oficina Nacional Estadounidense de Estándares formuló un conjunto completo de sintaxis estándar nacional estadounidense para el lenguaje C, llamado ANSI C, como estándar original para el lenguaje C. idioma. . [1] Actualmente, el 8 de diciembre de 2011, el estándar C11 publicado por la Organización Internacional de Normalización (ISO) y la Comisión Electrotécnica Internacional (IEC) es el tercer estándar oficial del lenguaje C y el último estándar del lenguaje C. Este el estándar es mejor Admite nombres de funciones de caracteres chinos e identificadores de caracteres chinos, lo que permite realizar la programación de caracteres chinos hasta cierto punto.
El lenguaje C es un lenguaje de programación de computadoras orientado a procesos, que es diferente de los lenguajes de programación orientados a objetos como C ++ y Java.
Sus compiladores incluyen principalmente Clang, GCC, WIN-TC, SUBLIME, MSVC, Turbo C , etc.
Nota: El siguiente contenido es solo una descripción general de los puntos de conocimiento, ¡y habrá explicaciones detalladas y profundas más adelante!
【2】 Interpretación del primer programa C
【Código de ejemplo】
// 头文件：头文件是对库函数进行声明的。<stdio.h> 是标准的输入输出文件.
#include <stdio.h>
// main 就是主函数，一个工程有且只能有一个主函数，main 是程序调用入口.
// int 函数的返回值类型
//（）里面为函数的形参，形参是函数外部数据，传递到函数内部的桥梁.
int main(int argc, char *argv[]){
// {} 是函数体。
// printf 将() 里面的字体输出到名目上面.
// ; 分号是结束语句.
printf("Hello World And Ubuntu!\n");
// return 第一：返回函数值. 第二：结束当前函数.
return 0;
}【3】Tipo de datos
[Descripción ampliada]
-
La unidad de almacenamiento más pequeña de una computadora es el binario y la unidad de asignación más pequeña de una computadora son los bytes.
-
El símbolo binario es b.
-
El símbolo de byte es B.
0000 0000 ~ 1111 1111 | 0 ~ 255【Correspondencia】
1B == 8b 1KB = 1024B1MB = 1024KB1GB = 1024MB1TB = 1024GB1PB = 1024TB1EB = 1024PB
char //字符数据类型
short //短整型
int //整型
long //长整型
long long //更长的整形
float //单精度浮点数
double //双精度浮点数-
¿Por qué aparece este tipo?
-
¿Cómo se prueba el tamaño de cada tipo?
【Código de ejemplo】
int main() {
printf("%d\n", sizeof(char)); // 1
printf("%d\n", sizeof(short)); // 2
printf("%d\n", sizeof(int)); // 4
printf("%d\n", sizeof(long)); // 4
printf("%d\n", sizeof(long long)); // 8
printf("%d\n", sizeof(float)); // 4
printf("%d\n", sizeof(double)); // 8
printf("%d\n", sizeof(long double)); // 8
return 0;
}
// 类型的使用
char ch = 'w';
int weight = 120;
int salary = 20000;Nota: La existencia de tantos tipos es en realidad para expresar más abundantemente varios valores de la vida.
【4】Constante variable
Algunos valores en la vida son constantes (como: pi, sexo, número de cédula, tipo de sangre, etc.).
Algunos valores son variables (por ejemplo: edad, peso, salario).
Los valores invariantes están representados por el concepto de constantes en lenguaje C, y los valores variables están representados por variables en lenguaje C.
【4.1】Cómo definir variables
【Código de ejemplo】
int age = 150;
float weight = 45.5f;
char ch = 'w';【4.2】Clasificación de variables
-
variables locales
-
variables globales
【Código de ejemplo】
#include <stdio.h>
int global = 2019;//全局变量
int main()
{
int local = 2018;//局部变量
//下面定义的global会不会有问题？
int global = 2020;//局部变量
printf("global = %d\n", global);
return 0;
}Resumen: en realidad, no hay nada de malo en la definición de variable local variable global.Cuando la
【4.3】Uso de variables
【Código de ejemplo】
#include <stdio.h>
int main() {
int num1 = 0;
int num2 = 0;
int sum = 0;
printf("输入两个操作数:>");
scanf("%d %d", &num1, &num2);
sum = num1 + num2;
printf("sum = %d\n", sum);
return 0;
}【4.4】Alcance y ciclo de vida de las variables
El alcance es un concepto de programación. En términos generales, el nombre utilizado en un fragmento de código de programa no siempre es válido/disponible, y el rango de código que limita la disponibilidad del nombre es el alcance del nombre.
-
El alcance de una variable local es el alcance local donde se encuentra la variable.
-
El alcance de las variables globales es todo el proyecto.
Ciclo de vida , el ciclo de vida de una variable se refiere al período de tiempo entre la creación de la variable y la destrucción de la variable.
-
El ciclo de vida de las variables locales es: el ciclo de vida comienza al ingresar al alcance y finaliza al salir del alcance.
-
El ciclo de vida de las variables globales es: el ciclo de vida de todo el programa.
【4.5】Clasificación constante
Las formas de definición de constantes y variables en lenguaje C son diferentes. Las constantes en lenguaje C se dividen en los siguientes tipos:
-
Constante literal.
-
constante variable constante modificada.
-
#define la constante de identificador definida.
-
Constantes de enumeración.
【Código de ejemplo】
#include <stdio.h>
// 举例枚举类型
enum Sex {
MALE,
FEMALE,
SECRET
};
//括号中的MALE,FEMALE,SECRET是枚举常量
int main() {
//字面常量演示
3.14;//字面常量
1000;//字面常量
//const 修饰的常变量
const float pai = 3.14f; //这里的pai是const修饰的常变量
pai = 5.14;//是不能直接修改的！❌
//#define的标识符常量 演示
#define MAX 100
printf("max = %d\n", MAX);
//枚举常量演示
printf("%d\n", MALE);
printf("%d\n", FEMALE);
printf("%d\n", SECRET);
//注：枚举常量的默认是从0开始，依次向下递增1的
return 0;
}Nota: El ejemplo anteriorpaise llamaconstvariable constante modificada.constLa variable constante modificada en lenguaje C solo limita la variable en el nivel gramatical ypaino se puede cambiar directamente, peropaisigue siendo una variable en esencia, por lo que se llama variable constante.
【5】Cuerda
"hello bit.\n" Esta （Double Quote）cadena de caracteres entre comillas dobles se denomina cadena literal （String Literal）o simplemente cadena.
【Código de ejemplo】
#include <stdio.h>
// 下面代码，打印结果是什么？为什么？（突出'\0'的重要性）
int main() {
char arr1[] = "bit";
char arr2[] = { 'b', 'i', 't' };
char arr3[] = { 'b', 'i', 't', '\0' };
printf("%s\n", arr1);
printf("%s\n", arr2);
printf("%s\n", arr3);
return 0;
}[Referencia ilustrada]
Nota: La marca de final de una cadena es un carácter de escape \0. Al calcular la longitud de una cadena, \0 es la marca de final y no se cuenta como el contenido de la cadena.
【6】Personajes de escape
Si queremos imprimir un en la pantalla, ¿ 目录： cómo escribimos el código?c:\code\test.c
【Código de ejemplo】
#include <stdio.h>
int main() {
printf("c:\code\test.c\n");
return 0;
}
实际上程序运行的结果是这样的：
c:code est.cTengo que mencionar los personajes de escape aquí. Como sugiere el nombre, los caracteres de escape cambian de significado. Veamos algunos caracteres de escape:
| Personaje de escape | Definición |
|---|---|
| \? | Se utiliza al escribir varios signos de interrogación seguidos para evitar que se analicen en palabras de tres letras. |
| ' | utilizado para representar constantes de caracteres |
| \“ | Se utiliza para representar comillas dobles dentro de una cadena. |
| \ | Se utiliza para representar una barra invertida, evitando que se interprete como un carácter de secuencia de escape. |
| \a | Carácter de advertencia, timbre |
| \b | carácter de retroceso |
| \F | carácter de alimentación de papel |
| \norte | nueva línea |
| \r | Ingresar |
| \ t | pestaña horizontal |
| \v | pestaña vertical |
| \ddd | ddd representa de 1 a 3 dígitos octales. Por ejemplo: \130 X |
| \xdd | dd representa 2 dígitos hexadecimales. Por ejemplo: \x30 0 |
#include <stdio.h>
int main() {
//问题1：在屏幕上打印一个单引号'，怎么做？
//问题2：在屏幕上打印一个字符串，字符串的内容是一个双引号“，怎么做？
printf("%c\n", '\'');
printf("%s\n", "\"");
return 0;
}[Pregunta de prueba escrita] Encuentra la longitud de una cuerda.
//程序输出什么？
#include <stdio.h>
int main() {
printf("%d\n", strlen("abcdef"));
// \62被解析成一个转义字符
printf("%d\n", strlen("c:\test\628\test.c"));
return 0;
}
// "c:\test\628\test.c"
// c : \t e s t \62 8 \t e s t . c 【7】Comentarios
Si hay códigos innecesarios en el código, puede eliminarlos directamente o comentarlos. Algunos códigos en el código son difíciles de entender, por lo que puede agregar comentarios.
Los comentarios vienen en dos estilos:
-
Comentarios de estilo de lenguaje C/ xxxxxx /, defecto: los comentarios no se pueden anidar.
-
Comentarios de estilo C++ //xxxxxxxx puede comentar en una o varias líneas.
【Código de ejemplo】
#include <stdio.h>
int Add(int x, int y) {
return x+y;
}
/*C语言风格注释
int Sub(int x, int y)
{
return x-y;
}
*/
int main() {
//C++注释风格
//int a = 10;
//调用Add函数，完成加法
printf("%d\n", Add(1, 2));
return 0;
}【8】Seleccionar declaración
Si estudias mucho, obtienes una buena oferta durante el reclutamiento escolar y alcanzas la cima de tu vida. Si no estudias, graduarte significa desempleo y te vas a casa a vender batatas. ¡Esta es tu elección!
【Código de ejemplo】
#include <stdio.h>
int main() {
int coding = 0;
printf("你会去敲代码吗？（选择1 or 0）:>");
scanf("%d", &coding);
if (coding == 1) {
printf("坚持，你会有好offer\n");
}
else {
printf("放弃，回家卖红薯\n");
}
return 0;
}【9】 Declaración de bucle
Algunas cosas deben hacerse todo el tiempo, como mis conferencias día tras día y el estudio de todos día tras día.
¿Cómo implementar un bucle en lenguaje C?
【Código de ejemplo】
//while循环的实例
#include <stdio.h>
int main() {
printf("努力学习\n");
int line = 0;
while (line <= 20000) {
line++;
printf("我要继续努力敲代码\n");
}
if (line > 20000)
printf("好offer\n");
return 0;
}
【10】Función
Las características de las funciones son la simplificación del código y la reutilización del código.
【Código de ejemplo】
int main()
{
int num1 = 0;
int num2 = 0;
int sum = 0;
printf("输入两个操作数:>");
scanf("%d %d", &num1, &num2);
sum = num1 + num2;
printf("sum = %d\n", sum);
return 0;
}
// ----------------------------------------------------------------------------------
// 上述代码，写成函数如下：
#include <stdio.h>
int Add(int x, int y)
{
int z = x + y;
return z;
}
int main()
{
int num1 = 0;
int num2 = 0;
int sum = 0;
printf("输入两个操作数:>");
scanf("%d %d", &num1, &num2);
sum = Add(num1, num2);
printf("sum = %d\n", sum);
return 0;
}【11】Matriz
La definición de matriz está dada en lenguaje C: un conjunto de elementos del mismo tipo.
【11.1】 Definición de matriz
【Código de ejemplo】
int arr[10] = {1,2,3,4,5,6,7,8,9,10};//定义一个整形数组，最多放10个元素【11.2】Subíndice de matriz
El lenguaje C estipula que cada elemento de la matriz tiene un subíndice, y el subíndice comienza desde 0. Se puede acceder a la matriz a través del subíndice.
【Código de ejemplo】
int arr[10] = {0};
//如果数组10个元素，下标的范围是0-9
【11.3】Uso de matrices
【Código de ejemplo】
#include <stdio.h>
int main()
{
int i = 0;
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}【12】Operador
-
operadores aritméticos
+ - * / %-
operador de turno
>> <<-
Operadores de bits
& ^ |-
operador de asignación
= += -= *= /= &= ^= |= >>= <<=-
operador unario
! // 逻辑反操作
- // 负值
+ // 正值
& // 取地址
sizeof // 操作数的类型长度（以字节为单位）
~ // 对一个数的二进制按位取反
-- // 前置、后置--
++ // 前置、后置++
* // 间接访问操作符(解引用操作符)
(类型) // 制类型转换-
Operadores relacionales
> // 大于
>= // 大于等于
< // 小于
<= // 小于等于
!= // 用于测试“不相等”
== // 用于测试“相等”-
Operadores logicos
&& // 逻辑与
|| // 逻辑或-
operador condicional
exp1 ? exp2 : exp3-
expresión de coma
exp1, exp2, exp3, …expN-
Referencia de subíndice
[] -
Llamada de función
() .-
miembros de la estructura
->【13】Palabras clave comunes
El lenguaje C proporciona una gran cantidad de palabras clave, que están preestablecidas por el propio lenguaje y los usuarios no pueden crear palabras clave por sí mismos.
auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while
char // 字符类型
short // 短整型
int // 整型
long // 长整型
float // 单精度浮点数
double // 双精度浮点数
register // 寄存器变量
static // 静态变量
const // 只读变量
auto // 自动变量
extern // 声明变量外部可用（告知编译器 该变量在其他源文件定义 此处请通过编译）
sizeof // 测量类型的大小
typedef // 给类型取别名
volatile // 防止编译器优化
if else switch case default // 条件控制语句
for while break continue goto // 循环控制语句
【13.1】Def. de tipo de palabra clave
typedefComo sugiere el nombre, es una definición de tipo, que debe entenderse como un cambio de nombre de tipo.
【Código de ejemplo】
//将unsigned int 重命名为uint_32, 所以uint_32也是一个类型名
typedef unsigned int uint_32;
int main()
{
//观察num1和num2,这两个变量的类型是一样的
unsigned int num1 = 0;
uint_32 num2 = 0;
return 0;
}【13.2】Palabra clave estática
staticSe utiliza para modificar variables y funciones.
-
Variables locales modificadas: llamadas variables locales estáticas .
-
Variables globales modificadas: llamadas variables globales estáticas .
-
Funciones decoradas: llamadas funciones estáticas .
【13.2.1】Modificar variables locales
//代码1
#include <stdio.h>
void test()
{
int i = 0;
i++;
printf("%d ", i);
}
int main()
{
int i = 0;
for (i = 0; i < 10; i++)
{
test();
}
return 0;
}
//代码2
#include <stdio.h>
void test()
{
//static修饰局部变量
static int i = 0;
i++;
printf("%d ", i);
}
int main()
{
int i = 0;
for (i = 0; i < 10; i++)
{
test();
}
return 0;
}
Compare los efectos del código 1 y el código 2 para comprender el significado de las variables locales estáticas modificadas:
Conclusión: La modificación estática de las variables locales cambia el ciclo de vida de la variable, lo que permite que las variables locales estáticas aún existan fuera del alcance. El ciclo de vida no finaliza hasta el final del programa.
【13.2.2】Modificar variables globales
#include <stdio.h>
//代码1
//add.c
int g_val = 2018;
//test.c
int main()
{
printf("%d\n", g_val);
return 0;
}
//代码2
//add.c
static int g_val = 2018;
//test.c
int main()
{
printf("%d\n", g_val);
return 0;
}El código 1 es normal, pero el código 2 provocará un error de conectividad al compilar.
Conclusión: una variable global se modifica mediante estática, de modo que la variable global solo se puede usar en este archivo fuente y no se puede usar en otros archivos fuente.
【13.2.3】Función de modificación
//代码1
//add.c
int Add(int x, int y)
{
return x + y;
}
//test.c
int main()
{
printf("%d\n", Add(2, 3));
return 0;
}
//代码2
//add.c
static int Add(int x, int y)
{
return x + y;
}
//test.c
int main()
{
printf("%d\n", Add(2, 3));
return 0;
}El código 1 es normal, pero el código 2 provocará un error de conectividad durante la compilación.
Conclusión: una función se modifica estáticamente, de modo que esta función solo se puede usar en este archivo fuente y no se puede usar en otros archivos fuente.
【14】 Definir constantes y macros #definir
#include <stdio.h>
//define定义标识符常量
#define MAX 1000
//define定义宏
#define ADD(x, y) ((x)+(y))
int main()
{
int sum = ADD(2, 3);
printf("sum = %d\n", sum);
sum = 10 * ADD(2, 3);
printf("sum = %d\n", sum);
return 0;
}【15】Puntero
【15.1】Memoria
La memoria es una memoria particularmente importante en una computadora. Todos los programas en la computadora se ejecutan en la memoria. Por lo tanto, para usar la memoria de manera efectiva, la memoria se divide en pequeñas unidades de memoria. El tamaño de cada unidad de memoria es 1 byte . Para acceder efectivamente a cada unidad de memoria, la unidad de memoria está numerada y estos números se denominan dirección de la unidad de memoria .
Las variables se crean en la memoria (se asigna espacio en la memoria) y cada unidad de memoria tiene una dirección, por lo que las variables también tienen direcciones.
Obtenga la dirección de la variable de la siguiente manera:
【Código de muestra】
#include <stdio.h>
int main()
{
int num = 10;
#//取出num的地址
//注：这里num的4个字节，每个字节都有地址，取出的是第一个字节的地址（较小的地址）
printf("%p\n", &num);//打印地址，%p是以地址的形式打印
return 0;
}
Cómo almacenar la dirección requiere definir una variable de puntero.
int num = 10;
int *p;//p为一个整形指针变量
p = #【Código de muestra】
#include <stdio.h>
int main()
{
int num = 10;
int *p = #
*p = 20;
return 0;
}
Tomando como ejemplo los punteros a números enteros, se puede extender a otros tipos, como por ejemplo:
#include <stdio.h>
int main()
{
char ch = 'w';
char* pc = &ch;
*pc = 'q';
printf("%c\n", ch);
return 0;
}【15.2】El tamaño de las variables de puntero
#include <stdio.h>
//指针变量的大小取决于地址的大小
//32位平台下地址是32个bit位（即4个字节）
//64位平台下地址是64个bit位（即8个字节）
int main()
{
printf("%d\n", sizeof(char *));
printf("%d\n", sizeof(short *));
printf("%d\n", sizeof(int *));
printf("%d\n", sizeof(double *));
return 0;
}Conclusión: el tamaño del puntero es de 4 bytes en plataformas de 32 bits y de 8 bytes en plataformas de 64 bits.
【16】Estructura
La estructura es un punto de conocimiento particularmente importante en el lenguaje C. La estructura permite que el lenguaje C describa tipos complejos.
Por ejemplo, al describir un estudiante, el estudiante contiene: nombre + edad + sexo + número de estudiante. Esto solo se puede describir usando una estructura.
【Código de ejemplo】
struct Stu
{
char name[20];//名字
int age; //年龄
char sex[5]; //性别
char id[15]； //学号
};
// 结构体的初始化：
//打印结构体信息
struct Stu s = {"张三"， 20， "男"， "20180101"};
//.为结构成员访问操作符
printf("name = %s age = %d sex = %s id = %s\n", s.name, s.age, s.sex, s.id);
//->操作符
struct Stu *ps = &s;
printf("name = %s age = %d sex = %s id = %s\n", ps->name, ps->age, ps->sex, ps->id);