<Idioma C> Idioma C inicial

1 ¿Qué es el lenguaje C?

El lenguaje C es un lenguaje de programación de computadora de propósito general 面向过程. Fue desarrollado por Dennis Ritchie en Bell Laboratories alrededor de 1972 y se convirtió en un lenguaje ampliamente utilizado en la programación de sistemas y el desarrollo de aplicaciones. El lenguaje C tiene una sintaxis concisa, una velocidad de ejecución eficiente y potentes capacidades de control subyacentes, por lo que se usa ampliamente en sistemas operativos, sistemas integrados, desarrollo de juegos y otros campos.

En la década de 1980, para evitar diferencias en la gramática del lenguaje C utilizada por varios desarrolladores, la Oficina Nacional de Estándares de EE. UU. formuló un conjunto completo de gramática estándar nacional estadounidense para el lenguaje C, conocido como el estándar original del lenguaje ANSI CC.

El lenguaje C es un 面向过程lenguaje de programación de computadoras, 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 (VS), Turbo C, etc.

2 El primer programa en lenguaje C

#include <stdio.h>
int main() {
    
    
    printf("Hello World\n");
    return 0;
}

explicar:

#include <stdio.h>Esta línea de código es una directiva de preprocesamiento que le indica al compilador que incluya archivos de encabezado para las funciones estándar de entrada y salida stdio.h. El archivo de encabezado contiene prototipos de funciones y definiciones constantes para operaciones de entrada y salida.

La función principal del programa main, que es el punto de entrada del programa en lenguaje C. intEs el tipo de retorno de la función, maines el nombre de la función y los paréntesis vacíos después indican que la función no acepta ningún parámetro. Tiene que haber una función principal, y sólo puede haber una.

Una función en la biblioteca estándar del lenguaje C printf, que se usa para enviar la cadena de formato especificada a la salida estándar (generalmente la consola). Aquí, estamos pasando la cadena "Hello World" como argumento a printfla función e imprimirá esa cadena en la consola.

return 0, que indica el final de la función y devuelve el valor entero 0 a la persona que llama como valor de retorno de la función. En lenguaje C, un valor de retorno de 0 generalmente indica que el programa se ejecutó con éxito.

\nes un carácter de escape especial llamado nueva línea. Se utiliza para indicar una operación de salto de línea en la salida, es decir, para mover el cursor de salida al principio de la siguiente línea.

2.1 función de impresión

printfEs una función en la biblioteca estándar del lenguaje C, que se usa para formatear el texto de salida a la salida estándar (generalmente la consola). ``

Prototipo de función:

int printf(const char *format, ...);

printfLa función principal de la función es formatear el parámetro correspondiente en el texto especificado de acuerdo con el marcador de posición en la cadena de formato y enviarlo a la salida estándar. El valor de retorno de la función es el número de caracteres impresos. Los marcadores de posición %comienzan con y van seguidos de uno o más caracteres que especifican el tipo de argumento y el formato de la salida.

Los marcadores de posición de formato comunes y su uso son los siguientes:

%d: genera un entero decimal con signo.
%u: genera un entero decimal sin signo.
%f: Número de punto flotante de salida.
%c: Salida de un solo carácter.
%s: cadena de salida.
%p: Dirección del puntero de salida.
%xO %X: genera un entero hexadecimal.

Los caracteres ordinarios en la cadena de formato se muestran tal cual, excepto los marcadores de posición.

En printfla función, puede establecer la precisión, el ancho y el relleno de la salida mediante las opciones de formato. Aquí hay algunas opciones de formato de uso común:

1. Precisión (Precisión): se utiliza para especificar la precisión de salida de cadenas o números de punto flotante.

%.nf: establezca la precisión del número de punto flotante después del punto decimal en n dígitos.
%.*f: Especifique la precisión después del punto decimal del número de punto flotante a través de una variable, por ejemplo %.*f, pase un parámetro entero n más tarde para especificar el valor de la precisión.

float pi = 3.14159;
printf("%.2f", pi);  // 输出：3.14

int precision = 3;
printf("%.*f", precision, pi);  // 输出：3.142

2. Ancho: se utiliza para especificar el ancho del campo de salida, que se puede llenar con espacios u otros caracteres.

%nd: establezca el ancho de salida del entero en n caracteres y rellene la parte insuficiente con espacios.
%*d: Especifique el ancho de salida de un entero a través de una variable, por ejemplo %*d, pase un parámetro de entero n más tarde para especificar el valor del ancho.

int num = 42;
printf("%6d", num);  // 输出：    42

int width = 8;
printf("%*d", width, num);  // 输出：      42

3. Carácter de relleno (Carácter de relleno): se utiliza para especificar el carácter para rellenar el campo de salida, el valor predeterminado es un espacio.

%nd: agregue caracteres de relleno antes del ancho de salida n del entero, por ejemplo %6d, establezca el ancho de entero de la salida en 6 caracteres y rellene con espacios de forma predeterminada.
%*cd: Especifique el carácter de relleno a través de una variable, por ejemplo %*cd, pase un parámetro de carácter c más adelante para especificar el valor del carácter de relleno.

int num = 42;
printf("%06d", num);  // 输出：000042

char fillChar = '*';
printf("%*cd", 8, fillChar, num);  // 输出：******42

Función de escaneo 2.2

scanfes una función en la biblioteca estándar del lenguaje C para leer datos de entrada desde la entrada estándar (generalmente el teclado).

Prototipo de función:

int scanf(const char *format, ...);

valor de retorno:

scanfLa función devuelve el número de elementos de datos leídos correctamente o un número negativo si se produjo un error o se llegó al final de la entrada.

scanfDe acuerdo con los marcadores de posición en la cadena de formato, la función lee los datos correspondientes de la entrada estándar y los almacena en la variable especificada.

Los marcadores de posición de formato comunes y su uso son los siguientes:

%d: Leer un entero decimal con signo.
%u: Leer un entero decimal sin signo.
%f: Leer un número de punto flotante.
%c: Leer un solo carácter.
%s: Leer una cadena.
%p: Lee la dirección del puntero.
%xO %X: leer un entero hexadecimal.

A excepción de los marcadores de posición, los caracteres ordinarios en la cadena formateada se compararán con los datos de entrada, y se deben ingresar los caracteres correspondientes para que coincidan correctamente.

scanfLa función toma la entrada de acuerdo con la cadena de formato y los parámetros correspondientes, si los datos de entrada no coinciden con los marcadores de posición en la cadena de formato, puede causar errores de entrada o errores de tiempo de ejecución. Por lo tanto, al usar scanfla función, debe asegurarse de que la cadena de formato y los parámetros coincidan correctamente para evitar posibles problemas.

int main() {
    
    
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);   //输入3
    printf("You entered: %d\n", num);  //打印： You entered 3  
    return 0;
}

3 tipos de datos básicos

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

//类型的使用：
char ch = 'w';
int weight = 120;
int salary = 20000;

El tamaño del tipo de datos depende del compilador y de la implementación de la plataforma de destino. El compilador determina los tamaños de diferentes tipos de datos de acuerdo con la especificación estándar del lenguaje C y las características de la plataforma de destino.

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

4 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).

Las variables son identificadores que se utilizan para almacenar y manipular datos variables. En un programa, podemos declarar una variable y asignarle espacio de memoria, y luego podemos referirnos y modificar el valor almacenado en la memoria a través del nombre de la variable. El valor de una variable puede cambiar durante la ejecución del programa.

Las constantes son valores fijos que no se pueden cambiar. En los programas, podemos usar constantes para representar valores que no cambian, como números, caracteres o cadenas. El valor de una constante se determina cuando se define y no se puede modificar.

Las variables se utilizan para almacenar y manipular datos mutables cuyo valor puede cambiar durante la ejecución del programa.

Una constante se utiliza para representar un valor fijo inmutable cuyo valor se determina en el momento de la definición y ya no se puede modificar.

4.1 Método de definición de variables

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

4.2 Denominación de variables

Solo puede constar de letras (tanto mayúsculas como minúsculas), números y guiones bajos (_).

No puede comenzar con un número.

No puede exceder los 63 caracteres de longitud.

Los nombres de variables distinguen entre mayúsculas y minúsculas.

Los nombres de variables no pueden usar palabras clave.

4.3 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);//global = 2020
    return 0;
}

¡En realidad no hay nada malo con la definición de la variable local variable global anterior!

Cuando una variable local tiene el mismo nombre que una variable global, la variable local tiene prioridad.

Uso de variables:

#include <stdio.h>
int main() {
    
    
    int num1 = 0;
    int num2 = 0;
    int sum = 0;
    printf("输入两个操作数:>");
    scanf("%d %d", &num1, &num2);  //键盘输入： 3 5
    sum = num1 + num2;
    printf("sum = %d\n", sum);  //sum = 8
    return 0;
}

4.4 El alcance y el ciclo de vida de las variables

En lenguaje C, alcance variable (scope) y tiempo de vida (lifetime) son conceptos que describen la visibilidad y el tiempo de existencia de las variables en el programa.

Alcance (Scope) se refiere al rango visible de variables en el programa. Las variables tienen diferente accesibilidad en diferentes ámbitos. Existen los siguientes ámbitos en el lenguaje C:

Ámbito de bloque : una variable se declara dentro de un bloque de código (rodeada de llaves {}) y es visible dentro de ese bloque. Una vez que abandona el bloque, la variable sale de su alcance.

int main() {
      
      
    int x = 10;
    {
      
      
        int y = 20;
        printf("%d\n", x);  // 可以访问外部块中的变量
        printf("%d\n", y);  // 可以访问内部块中的变量
    }
    printf("%d\n", x);  // 可以继续访问外部块中的变量
    // printf("%d\n", y);  // 错误！超出了变量 y 的作用域
    return 0;
}

Alcance de la función : las variables se declaran dentro de una función y son visibles en toda la función. Los parámetros de función y las variables declaradas dentro de funciones tienen alcance de función.

int sum(int a, int b) {
      
      
    int result = a + b;
    return result;
}

int main() {
      
      
    int x = 10;
    int y = 20;
    int total = sum(x, y);
    printf("%d\n", total);
    // printf("%d\n", result);  // 错误！超出了变量 result 的作用域
    return 0;
}

Ámbito de archivo (ámbito global) (Ámbito de archivo) : las variables se declaran en todo el archivo de origen y se puede acceder a ellas mediante cualquier función del archivo. Las variables declaradas fuera de una función tienen alcance de archivo.

int globalVar = 10;

void function1() {
      
      
    printf("%d\n", globalVar);  // 可以访问文件作用域的变量
}

void function2() {
      
      
    printf("%d\n", globalVar);  // 可以访问文件作用域的变量
}

int main() {
      
      
    printf("%d\n", globalVar);  // 可以访问文件作用域的变量
    function1();
    function2();
    return 0;
}

Lifetime se refiere al intervalo de tiempo en el que existe una variable. La vida útil de una variable depende de su alcance y de cómo se declare. Existen los siguientes ciclos de vida variables en lenguaje C:

Variables automáticas (Automatic Variables) : las variables declaradas dentro de las funciones son variables automáticas. Su ciclo de vida comienza en la definición de la variable y termina al final del bloque de código en el que están contenidos. Las variables se recrean cada vez que se ingresa un bloque de código y se destruyen cuando se deja el bloque de código.

void function() {
    
    
    int x = 10;  // 自动变量，生命周期与函数调用关联
    printf("%d\n", x);
}

int main() {
    
    
    function();  // 调用函数
    // printf("%d\n", x);  // 错误！变量 x 不在作用域内
    return 0;
}

Variables estáticas (Variables estáticas)static : Las variables declaradas usando la palabra clave dentro de una función son variables estáticas. Su tiempo de vida comienza cuando el programa comienza a ejecutarse y finaliza cuando finaliza el programa. Las variables estáticas existen a lo largo de la ejecución del programa y se inicializan solo una vez.

void function() {
    
    
    static int count = 0;  // 静态变量，生命周期与程序运行关联
    count++;
    printf("%d\n", count);
}

int main() {
    
    
    function();  // 调用函数，输出：1
    function();  // 调用函数，输出：2
    function();  // 调用函数，输出：3
    return 0;
}

Variables globales : las variables declaradas fuera de una función son variables globales. Su tiempo de vida comienza cuando el programa comienza a ejecutarse y finaliza cuando finaliza el programa. Las variables globales existen a lo largo de la ejecución del programa y se inicializan solo una vez.

int globalVar;  // 全局变量

void function() {
    
    
    globalVar = 10;
}

int main() {
    
    
    function();  // 调用函数
    printf("%d\n", globalVar);  // 输出：10
    return 0;
}

4.5 Constantes

Las formas de definición de constantes y variables en lenguaje C son diferentes.

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

constante literal
constvariable constante modificada
#defineConstantes de identificador definidas
constante de enumeración

#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;             //被const修饰后，是不能直接修改的！

    //#define的标识符常量 演示
#define MAX 100
    printf("max = %d\n", MAX);// max = 100

    //枚举常量演示
    printf("%d\n", MALE);  //0
    printf("%d\n", FEMALE);//1
    printf("%d\n", SECRET);//2
    //注：枚举常量的默认是从0开始，依次向下递增1的
    return 0;
}

El ejemplo anterior paise llama constvariable constante modificada. constUna variable constante modificada en lenguaje C solo restringe la variable a nivel gramatical y paino se puede cambiar directamente, pero paisigue siendo una variable en esencia, por lo que se llama variable constante.

5 cadenas + carácter de escape + comentario

5.1 Cuerdas

"hello bit.\n"

Esta cadena de caracteres entre comillas dobles (Double Quote) se denomina cadena literal (String Literal), o simplemente cadena.

Nota: El final de la cadena es un carácter de escape \0. \0 es la marca final al calcular la longitud de la cadena 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);  //bit
    printf("%s\n", arr2);  //烫烫
    printf("%s\n", arr3);  //bit
    return 0;
}

arr1es una matriz de caracteres inicializada como una cadena. Contiene los caracteres 'b', 'i', 't' y el carácter nulo '\0', y el carácter nulo se agrega automáticamente al final de la matriz. Por lo tanto, printf("%s\n", arr1)lo que se imprime es la cadena completa "bit".
arr2es una matriz de caracteres inicializada con una lista de caracteres. Contiene los caracteres 'b', 'i', 't', pero no agrega el carácter nulo '\0' al final. Dado que %sel formato requiere una cadena terminada en nulo, printf("%s\n", arr2)continúa accediendo a arr2la memoria hasta que se encuentra el primer carácter nulo. El contenido de la memoria detrás de aquí no está definido, por lo que el resultado impreso no está definido.
arr3es una matriz de caracteres inicializada con una lista de caracteres, con el carácter nulo '\0' agregado explícitamente al final. Por lo tanto, printf("%s\n", arr3)lo que se imprime es la cadena completa "bit".

Una cadena en lenguaje C es una matriz de caracteres terminada por un carácter nulo '\0', que marca el final de la cadena. Si la cadena no termina en nulo, las funciones de manejo de cadenas (como printf, strcpy, strlenetc.) no procesarán la cadena correctamente y pueden causar resultados inesperados o errores. Por lo tanto, al manipular cadenas, es muy importante asegurarse de que las cadenas terminen con un carácter nulo '\0'.

5.2 Caracteres de escape

Si queremos imprimir un directorio en pantallac:\code\test.c

¿Cómo debemos escribir código?

#include <stdio.h>
int main() {
    
    
    printf("c:\code\test.c\n");
    return 0;
}
//输出结果：c:code  est.c

Aquí tengo que mencionar el carácter de escape. El carácter de escape, como su nombre lo indica, es cambiar el significado.

Veamos algunos caracteres de escape.

\n: nueva línea (nueva línea)
\t: carácter de tabulación (tab)
\": comillas dobles (doble comilla)
\': comilla simple (comilla simple)
\\: barra invertida (barra invertida)
\b: retroceso
\r: retorno de carro
\f: Avance de formulario (avance de formulario)
\v: pestaña vertical (pestaña vertical)
\a: símbolo de campana (alerta)
\0: carácter nulo
\?: signo de interrogación (signo de interrogación)
\ooo: carácter octal (donde ooorepresenta un número octal, el rango es \000hasta \377)
\xhh: carácter hexadecimal (donde hhrepresenta un número hexadecimal, el rango es \x00hasta \xFF)

Cabe señalar que si se usa una secuencia de caracteres de escape desconocida en un literal de cadena, o si se usa un número octal o hexadecimal fuera de rango en un literal de carácter, el compilador puede informar un error o generar un comportamiento definido por error. Por lo tanto, cuando utilice caracteres de escape, asegúrese de comprender su sintaxis y significado correctos.

#include <stdio.h>
int main()
{
    
    
    //问题1：在屏幕上打印一个单引号'，怎么做？
    //问题2：在屏幕上打印一个字符串，字符串的内容是一个双引号“，怎么做？
    printf("%c\n", '\'');
    printf("%s\n", "\"");
    return 0;
}

Preguntas con bolígrafo:

//程序输出什么？
#include <stdio.h>
int main()
{
    
    
    printf("%d\n", strlen("abcdef"));  //6
    // \62被解析成一个转义字符
    printf("%d\n", strlen("c:\test\628\test.c"));  //14
    return 0;
}

5.3 Notas

El código innecesario en el código se puede eliminar directamente o comentar
Algunos códigos en el código son difíciles 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;
}

Los comentarios vienen en dos sabores:

comentarios estilo C/*xxxxxx*/
- Desventaja: no se pueden anidar comentarios
Comentarios de estilo C++//xxxxxxxx
- Puede comentar una línea o varias líneas

6. Palabras clave comunes

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

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.

6.1 Definiciones de tipos de palabras clave

typedef, como sugiere el nombre, es una definición de tipo, y aquí debe entenderse como un cambio de nombre de tipo.

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

6.2 Palabra clave estática

En lenguaje C: static se usa para modificar variables y funciones

Decorar variables locales - llamadas variables locales estáticas

Decorar variables globales - llamadas variables globales estáticas

Funciones de decorador - llamadas funciones estáticas

Modificar variables locales

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

Resultado de salida:

1 1 1 1 1 1 1 1 1 1

Añadir estática:

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

Resultado de salida:

1 2 3 4 5 6 7 8 9 10

Compare el efecto del código 1 y el código 2 para comprender la importancia de la modificación estática de las variables locales.

en conclusión:

La modificación estática de las variables locales cambia el ciclo de vida de las variables

Deje que las variables locales estáticas aún existan fuera del alcance, y el ciclo de vida no terminará hasta el final del programa.

Decorar variables globales

Ejemplo:

//代码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 y 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 esta variable global solo se puede usar en este archivo de origen y no se puede usar en otros archivos de origen.

función modificadora

Ejemplo:

//代码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 y 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.

7. #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 = 5

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

    return 0;
}