El lenguaje C es un lenguaje de programación de computadora de propósito 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 se pueda compilar de manera fácil, manejar memoria de bajo nivel, generar una pequeña cantidad de código de máquina y ejecutarse sin soporte de tiempo de ejecución. Aunque el lenguaje C proporciona muchas funciones de procesamiento de bajo nivel, aún mantiene buenas características multiplataforma. Los programas en lenguaje C escritos en una especificación estándar se pueden compilar en muchas plataformas informáticas, incluso incluyendo algunos procesadores integrados (MCU o MCU). plataformas operativas como las supercomputadoras.

En la década de 1980, para evitar diferencias en la gramática del lenguaje C utilizada por varios desarrolladores, la Oficina Nacional Estadounidense de Estándares formuló un conjunto completo de gramáticas estándar nacionales estadounidenses para el lenguaje C, llamado ANSI C, como el estándar inicial de C. lenguaje. .

En la actualidad, el 8 de diciembre de 2011, el estándar C11 emitido 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, que mejor admite caracteres chinos Los nombres de funciones y los identificadores de caracteres chinos realizan 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.

2. El primer programa en lenguaje C

#include <stdio.h>//引用头文件，使我们可以使用C语言库本身就已经提供给我们的函数，即库函数
int main()//main()是主函数
{
    printf("hello world\n");//printf()是输出函数，'\n'是换行的意思
    return 0;//使程序退出，0的意思是程序正常退出
}
//解释：
//main函数是程序的入口
//一个工程中main函数有且仅有一个

Resultado de la ejecución del programa:

3. Tipos de datos

char // tipo de datos del carácter

corto // entero corto

int //forma

largo // entero largo

long long //Entero más largo

float // número de punto flotante de precisión simple

double // número de punto flotante de precisión doble

//¿El lenguaje C tiene un tipo de cadena?

Respuesta: El lenguaje C en sí mismo no tiene un tipo de cadena. Las cadenas que usamos en los programas de lenguaje C son en realidad matrices de caracteres, es decir, ¡múltiples caracteres constituyen una cadena!

Aquí hay dos formas de definir cadenas:
#include<stdio.h>
int main()
{
	char string1[] = "abc";
	char string2[] = { 'a','b','c' };
	return 0;
}
La diferencia entre estos dos métodos no se explica en detalle aquí, y se explicará en detalle más adelante. ¡Solo espero que todos puedan entenderlo!

¿Por qué existe ese tipo?

Respuesta: Por un lado, puede almacenar datos más diversos para facilitar el procesamiento de datos; por otro lado, ¡la razón es ahorrar mejor nuestro espacio de memoria! En cuanto a por qué dice esto, puede aprender sobre el espacio de memoria ocupado por diferentes tipos de datos más adelante, y puede tener una comprensión más profunda del mismo.

¿Cuál es el tamaño de cada tipo?
#include <stdio.h>
int main()
{
    printf("%d\n", sizeof(char));
    printf("%d\n", sizeof(short));
    printf("%d\n", sizeof(int));
    printf("%d\n", sizeof(long));
    printf("%d\n", sizeof(long long));
    printf("%d\n", sizeof(float));
    printf("%d\n", sizeof(double));
    printf("%d\n", sizeof(long double));
    return 0;
}
El siguiente es el resultado de ejecutar el código:

Tipo de uso:
char ch = 'w';
int weight = 120;
int salary = 20000;

3. Variables, constantes

Algunos valores en la vida son constantes (por ejemplo: pi, género, número de identificación, tipo de sangre, etc.)

Algunos valores son variables (por ejemplo: edad, peso, salario).

El valor constante está representado por el concepto de constante en lenguaje C, y el valor variable está representado por variable en lenguaje C.

3.1 Cómo definir variables

int age = 150;
float weight = 45.5f;
char ch = 'w';

3.2 Clasificación de variables

variable local

variable global
#include <stdio.h>
int global = 2019;//全局变量
int main()
{
    int local = 2018;//局部变量
    //下面定义的global会不会有问题？
    int global = 2020;//局部变量
    printf("global = %d\n", global);
    return 0;
}
El resultado de salida muestra:

Resumir:

¡No hay problema con la definición de la variable local variable global anterior!

Cuando una variable local y una variable global tienen el mismo nombre, la variable local se usa primero , ¡que es el principio de prioridad local que solemos decir!

3.3 Uso de variables

#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;
}
¡Aquí hay una breve introducción a la función printf() y la función scanf()!

Función printf(): Función de salida. Se generará la salida entre comillas dobles, y % es el formato de salida de la variable de control, es decir, desempeña un papel en el control de formato. Por ejemplo, %d es para imprimir y mostrar la variable en la pantalla en el formulario de un número entero, y %c es un carácter. ¡Imprimir en forma de un tipo! Después de la coma está la variable que queremos generar. Todos deben prestar atención en este lugar. ¡El control de formato % debe corresponder al significado de las siguientes variables!

Función scanf(): Función de entrada. Al igual que el anterior, el % también se usa para el control de formato, pero la diferencia con el anterior es que aquí se realiza el control del formato de entrada, como por ejemplo %d, que es almacenar el contenido de nuestra entrada en forma de un entero en nuestra variable. , aquí es lo mismo que antes, debe corresponder estrictamente a la variable después de la coma, pero todavía hay un punto que necesita la atención de todos. Por ejemplo, cuando ingresamos, estamos en medio de % d %d dos %d Hay un espacio para separar, luego también necesitamos separar entre dos variables al ingresar a través del teclado, es decir, nuestra entrada debe corresponder estrictamente al contenido entre comillas dobles.

Dado que esta sección está diseñada para llevarlo a un primer vistazo al lenguaje C, ¡no entraré en demasiadas explicaciones!

3.4 Alcance y ciclo de vida de las variables

(1 Alcance

El alcance es un concepto de programación. En términos generales, un nombre utilizado en un código de programa no siempre es válido/disponible, y el alcance del código que limita la disponibilidad del nombre es el alcance del nombre.

1. El ámbito de una variable local es el ámbito local donde reside la variable.

2. El alcance de las variables globales es todo el proyecto.

(2) 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.

1. El ciclo de vida de una variable local es: comienza el ciclo de vida de entrar en el alcance y termina el ciclo de vida de salir del alcance.

2. El ciclo de vida de las variables globales es: el ciclo de vida de todo el programa.

3.5 Constantes

Las definiciones de constantes y variables en lenguaje C difieren en forma.

Las constantes en lenguaje C se dividen en las siguientes categorías:

constante literal

variable constante modificada por const

Constantes de identificador definidas por #define

enumeración constante

variables constantes modificadas const:
#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 pai en el ejemplo anterior se denomina variable constante modificada por const. La variable constante modificada por const en lenguaje C solo restringe que la variable pai se cambie directamente en el nivel de sintaxis, pero pai es esencialmente una variable, por lo que se llama un la variable constante.

4. Cadena + carácter de escape + comentario

4.1 Cuerdas

"hello bit.\n"
Esta cadena de caracteres encerrados entre comillas dobles se llama String Literal, o simplemente una cadena.

Nota: El final de la cadena es un carácter de escape \0. Al calcular la longitud de la cadena, \0 es la marca final y no se cuenta como el contenido de la cadena.
#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;
}
Ahora podemos ver que tenemos un formulario distorsionado cuando generamos arr2, ¿por qué sucede esto? Debido a que arr2 no contiene la marca final de la cadena, es decir, '\0', ¡aparecerán los caracteres distorsionados anteriores!

Darse cuenta:

1. Cuando usamos la función printf() para generar una salida en forma de cadena, ¡la salida solo se detendrá cuando se encuentre '\0'!

2. Cuando usamos la forma anterior de arr1 para definir una cadena, la cadena en "" ha incluido automáticamente la marca final de la cadena, es decir, '\0'.

3. Cuando usamos el método de definición de cadena {}, debemos recordar agregar la marca final de la cadena, aunque a veces no la usamos, pero esto es lo que debemos hacer, y esto también es un calificado Las cualidades necesarias de programadores, por supuesto, a veces no es necesario agregarlos.Durante el período de principiante, se recomienda agregarlos.

4.2 Caracteres de escape

Supongamos que queremos imprimir un directorio en la pantalla: c:\code\test.c

¿Cómo debemos escribir código?
#include <stdio.h>
int main()
{
    printf("c:\code\test.c\n");
    return 0;
}
Pero, de hecho, el resultado de la impresión es este:

Aquí tenemos que mencionar los caracteres de escape. Los caracteres de escape, como su nombre indica, son para cambiar el significado.

Vea algunos caracteres de escape a continuación.

Aquí hay un ejercicio simple:
#include <stdio.h>
int main()
{
    //问题1：在屏幕上打印一个单引号'，怎么做？
    //问题2：在屏幕上打印一个字符串，字符串的内容是一个双引号“，怎么做？
    printf("%c\n", '\'');
    printf("%s\n", "\"");
    return 0;
}
La siguiente es una pregunta de prueba escrita, ¡haga que todos la entiendan!
//程序输出什么？
#include <stdio.h>
int main()
{
    printf("%d\n", strlen("abcdef"));
    // \62被解析成一个转义字符
    printf("%d\n", strlen("c:\test\628\test.c"));
    return 0;
}
Aquí está el resultado de nuestra ejecución en VS:

¿Por qué obtienes el resultado anterior?

Primero echemos un vistazo a strlen(), la función de esta función es encontrar la longitud de la cadena, y se detendrá cuando encuentre la marca final de la cadena, pero debe prestar atención a que la marca final de la la cadena '\0' en sí misma no forma parte de la longitud de la cadena.

Veamos primero el código anterior. El contenido de la cadena entre corchetes strlen() es abcdef y la marca final de la cadena '\0', pero dado que la marca final de la cadena no es parte de la longitud de la cadena, la cuerda La longitud es 6.

A continuación, veamos el siguiente fragmento de código. Ya hemos aprendido acerca de los caracteres de escape. Aquí debemos darle un concepto claro. El carácter de escape se considera como un carácter, incluso si su forma es \ seguida de 1 o varios caracteres. , pero la función strlen() solo lo trata como un carácter. Entonces, ¿por qué nuestro compilador da los resultados anteriores no es difícil de entender, y los resultados anteriores no son difíciles de entender? Porque \ es seguido por octal, es decir, solo números del 0 al 7, no 8, ¡entonces 8 no está incluido! ¡También hay un carácter de escape después de \t! ¡El resultado final es 14!

5. Notas

El código innecesario en el código se puede eliminar directamente o comentar

Parte del código en el código es más difícil de entender, puede agregar un texto de comentario

por 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;
}
Las anotaciones vienen en dos sabores:

Comentarios estilo C /*xxxxxx*/ Defecto: No se pueden anidar comentarios

Comentarios de estilo C++//xxxxxxxx puede comentar en una o varias líneas

6. Seleccione Declaración

Si estudias mucho, obtienes una buena oferta durante el reclutamiento escolar y alcanzas la cima de tu vida, ¡tu novia seguirá estando a tu lado!

Si no estudias, la graduación significa desempleo, ¡tu novia terminó contigo!

¡Esta es la elección!
#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;
}
Aquí hay una captura de pantalla de la ejecución:

7. Declaración de bucle

¿Cómo implementar un bucle en lenguaje C?

declaración while - explicar

para declaración (discusión posterior)

hacer ... mientras declaración (más tarde)
#include <stdio.h>
int main()
{
    int line = 0;
    while (line <= 20000)
    {
        line++;
        printf("我要继续努力敲代码\n");
    }
    if (line > 20000)
        printf("好offer\n");
    return 0;
}

8. Funciones

#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;
}
上述代码，写成函数如下：
#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;
}

La característica de la función es simplificar el código y reutilizar el código.

9. Matrices

¿Cómo almacenar los números del 1 al 10?

El lenguaje C da la definición de una matriz: una colección de elementos del mismo tipo.

9.1 Definición de matriz

int arr[10] = {1,2,3,4,5,6,7,8,9,10};//定义一个整形数组，最多放10个元素

9.2 Subíndice de matrices

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 las matrices subscribiendo.

por ejemplo:
int arr[10] = {0};
//如果数组10个元素，下标的范围是0-9

9.3 Uso de matrices

#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;
}

El resultado de la ejecución se muestra en la siguiente figura:

10. Operadores

operadores aritméticos

+ añadir

- reducir

* tomar

/ retirar

% Restante

Hay muchos operadores, ¡así que no los enumeraré todos aquí! ¡Hablaremos de eso más tarde!
#include<stdio.h>
int main()
{
	int a = 10;
	int b = 5;
	int c = 3;
	printf("%d\n", a + b);
	printf("%d\n", a - b);
	printf("%d\n", a * b);
	printf("%d\n", a / b);
	printf("%d\n", a % c);
	return 0;
}
El siguiente es el resultado de ejecución:

11. Palabras clave comunes

auto

romper

caso

carbonizarse

constante

Seguir

defecto

hacer

doble

demás

enumeración

externo

flotar

por

ir a

Si

En t

largo

Registrarse

devolver

corto

firmado

tamaño de

estático

estructura

cambiar

definición de tipo

Unión

no firmado

vacío

volátil

mientras

Sin entrar primero en una introducción exhaustiva, ¡lo presentaré paso a paso! Aquí hay una breve introducción a algunos!

11.1 Definición de tipo de palabra clave

Typedef Como su nombre lo indica, es una definición de tipo, que debe entenderse como un cambio de nombre de tipo.

por ejemplo:
typedef unsigned int uint_32;
int main()
{
    //观察num1和num2,这两个变量的类型是一样的
    unsigned int num1 = 0;
    uint_32 num2 = 0;
    return 0;
}

11.2 La palabra clave estática

En lenguaje C:

static se usa para modificar variables y funciones

Variables locales decoradas - llamadas variables locales estáticas

Variables globales decoradas - llamadas variables globales estáticas

Función decorada - llamada función estática

11.2.1 Decoración de 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;
}
El resultado de ejecutar el código 1:

El resultado de ejecutar el código 2:

En conclusión:

La modificación estática de las variables locales cambia el ciclo de vida de las variables, de modo que las variables locales estáticas aún existen fuera del alcance y el ciclo de vida no finaliza hasta el final del programa.

11.2.2 Decoración de variables globales

Nota: add.c y test.c representan dos archivos fuente diferentes
//代码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, el código 2 tendrá un error de conectividad al compilar.

En conclusión:

Una variable global se modifica por estática, de modo que la variable global solo se puede usar en este archivo de origen y no se puede usar en otros archivos de origen.

11.2.3 Funciones decoradas

//代码1
//add.c
int Add(int x, int y)
{
    return c + y;
}
//test.c
int main()
{
    printf("%d\n", Add(2, 3));
    return 0;
}
//代码2
//add.c
static int Add(int x, int y)
{
    return c + y;
}
//test.c
int main()
{
    printf("%d\n", Add(2, 3));
    return 0;
}
El código 1 es normal, el código 2 tendrá un error de conectividad al compilar.

En conclusión:

Una función se modifica por estática, de modo que esta función solo se puede usar en este archivo de origen y no se puede usar en otros archivos de origen.

12. #define define constantes y macros

//define定义标识符常量
#define MAX 1000
//define定义宏
#define ADD(x, y) ((x)+(y))
#include <stdio.h>
int main()
{
    int sum = ADD(2, 3);
    printf("sum = %d\n", sum);

    sum = 10 * ADD(2, 3);
    printf("sum = %d\n", sum);

    return 0;
}

resultado de la operación:

13. Punteros

13.1 Memoria

La memoria es una memoria particularmente importante en la computadora, y la operación de los programas en la computadora se lleva a cabo en la memoria .

Por lo tanto, para usar la memoria de manera eficiente, la memoria se divide en pequeñas unidades de memoria y el tamaño de cada unidad de memoria es de 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. Saque la dirección variable de la siguiente manera:
#include <stdio.h>
int main()
{
    int num = 10;
    &num;//取出num的地址
       //注：这里num的4个字节，每个字节都有地址，取出的是第一个字节的地址（较小的地址）
    printf("%p\n", &num);//打印地址，%p是以地址的形式打印
    return 0;
}
Cómo almacenar la dirección, debe definir una variable de puntero.
int num = 10;
int *p;//p为一个整形指针变量
p = &num;
Ejemplos de uso del puntero:
#include <stdio.h>
int main()
{
    int num = 10;
    int* p = &num;
    *p = 20;
    return 0;
}
Tomando como ejemplo el puntero entero, 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;
}

13.2 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;
}
¡Lo anterior es la plataforma de 32 bits!

¡Lo anterior es una plataforma de 64 bits!

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.

14. Estructuras

La estructura es un punto de conocimiento particularmente importante en el lenguaje C. La estructura hace que el lenguaje C sea capaz de describir tipos complejos. Por ejemplo, al describir a un estudiante, el estudiante incluye: nombre + edad + género + número de estudiante. Solo se pueden usar estructuras para describirlas aquí.

P.ej:
struct Stu
{
    char name[20];//名字
    int age;      //年龄
    char sex[5];  //性别
    char id[15]； //学号
};
Inicialización de la estructura:
//打印结构体信息
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);

El tutorial de lenguaje C más sólido de la historia ---- primera comprensión del lenguaje C

1. ¿Qué es el lenguaje C?