Tabla de contenido
1. Cadena + carácter de escape
1. Definición de tipo de palabra clave
6. #define define constantes y macros
1. Cadena + carácter de escape
1. Cuerda
Una cadena de caracteres entre comillas dobles se denomina literal de cadena o cadena para abreviar. En lenguaje C, las matrices de caracteres se utilizan generalmente para almacenar cadenas. (La marca 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).
El siguiente código destaca la importancia de '\0' en las cadenas :
#include<stdio.h>
#include<string.h>
int main()
{
char a[] = "bit";
char b[] = { 'b','i','t' };
char c[] = { 'b','i','t','\0' };
printf("%s\n", a);
printf("%s\n", b);
printf("%s\n", c);
printf("%d\n", strlen(b));
printf("%d\n", strlen(c));
return 0;
}El resultado de su funcionamiento es:
A juzgar por los resultados anteriores:
Comparando la salida de la segunda línea con la salida de la tercera línea, podemos ver que cuando la cadena no termina con '\0', se generarán valores aleatorios más tarde. En ausencia de '\0' al final, la longitud 15 de la salida del arreglo b en la cuarta línea es un valor aleatorio.
En el código anterior, la función strlen utilizada es una función de cadena, que se utiliza para encontrar la longitud de la cadena, es decir, desde la dirección dada, cuenta los caracteres hacia atrás hasta el final de '\0', '\0' no se incluyen estadísticas.
Para funciones de cadena más detalladas, puede leer este artículo: http://t.csdn.cn/d321I
2. Personajes de escape
Antes que nada, pensemos en este problema, imprima un directorio en la pantalla: c:\code\test.c, ¿cómo debemos escribir el código en este momento?
Primero intentemos generar directamente con printf, el código es el siguiente:
#include <stdio.h>
int main()
{
printf("c:\code\test.c\n");
return 0;
}El resultado de su funcionamiento es:
Obviamente, no es el resultado que queremos. Si queremos generar el resultado correcto, necesitamos usar caracteres de escape en este momento .
El carácter de escape, como su nombre lo indica, es cambiar el significado. Algunos caracteres de escape se enumeran a continuación:
| Personaje de escape | paráfrasis |
| \? | Se usa cuando se escriben varios signos de interrogación seguidos, evitando que se analicen en palabras de tres letras |
| \' | Se utiliza para representar constantes de caracteres' |
| \" | Se usa para denotar comillas dobles dentro de una cadena |
| \\ | Se utiliza para denotar una barra invertida, evitando que se interprete como una secuencia de escape. |
| \a | carácter de advertencia, pitido |
| \b | retroceso |
| \F | Avance de formulario |
| \norte | nueva línea |
| \r | retorno de carro |
| \t | pestaña horizontal |
| \v | pestaña vertical |
| \ddd | ddd representa 1~3 números octales. Por ejemplo: \130 significa carácter X |
| \xdd | dd representa dos dígitos hexadecimales. Por ejemplo: \x30 significa carácter 0 |
Los caracteres de escape \ddd y \xdd necesitan usar el ASCLL y la conversión base de los caracteres. Si no está familiarizado con la tabla ASCLL, puede bajar por su cuenta y registrar cuidadosamente los valores ASCLL de los caracteres de uso común. .
Luego imprima un directorio en la pantalla: c:\code\test.c El código correcto es:
#include <stdio.h>
int main()
{
printf("c:\\code\\test.c\n");
return 0;
}El resultado de la operación es: 
Para el carácter de escape \?, su código de análisis es el siguiente:
#include <stdio.h>
int main()
{
//\?是为了不让？被解析为三字母词
//三字母词 - ??) ——> ]
printf("%s\n","(are you ok\?\?)");
//输出结果为：(are you ok??)，否则结果为：(are you ok]
return 0;
}Veamos un ejemplo:
#include <stdio.h>
int main()
{
printf("%d\n", strlen("abcdef"));
// \x11和\62被解析成一个转义字符
printf("%d\n", strlen("c:\test\x11\628\test.c"));
return 0;
}¿Cuál debería ser la salida del código anterior?
El resultado es 6,15. La primera salida es fácil de entender, es decir, la cantidad de caracteres, entonces, ¿por qué la segunda salida es 15? La respuesta es que \t, \x11 y \62 en la cadena son todos caracteres de escape.
2. Notas
Los comentarios vienen en dos sabores:
-
Comentarios de estilo C /*xxxxxx*/, defecto: no se pueden anidar comentarios
-
Comentario de estilo C++ //xxxxxxxx, puede comentar una línea o varias líneas
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;
}
3. matriz
Los arreglos se definen en lenguaje C de la siguiente manera: una colección de elementos del mismo tipo.
1. Definición de matriz
int arr[10] = {1,2,3,4,5,6,7,8,9,10};//定义一个整形数组，最多放10个元素La matriz arr, donde los corchetes [ ] también pueden no tener tamaño, el tamaño se determina de acuerdo con la cantidad de elementos que se dan más adelante.
2. El subíndice de la 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 las matrices subscribiendo.
Por ejemplo:
int arr[10] = {0};
//如果数组有10个元素全为0，下标的范围是0-9
3. El uso de arreglos
código:
#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;
}Cuarto, el operador
| operador aritmético | + - * / % |
| operador de turno | >> << |
| operador bit a bit | & ^ | (como el operador de cambio, opera en bits binarios) |
| operador de asignación | = += -= *= /= &= |= >>= <<= |
| operador relacional | > >= < <= != == |
| operador lógico | && (Y lógico) || (O lógico) |
| operador condicional |
exp1
?
exp2 : exp3
|
| expresión de coma |
exp1，
exp2 ，exp3，...expn
|
| Referencias a subíndices y llamadas a funciones | [ ] ( ) |
| miembro de la estructura | . -> |
/ División en Operadores Aritméticos:
- El resultado del cálculo es el cociente después de la divisibilidad.
- La división incluye la división de enteros y la división de coma flotante. En la división de coma flotante, al menos uno de los divisores y dividendos debe ser un número de coma flotante.
Operador módulo %: El resultado es el resto, que solo es aplicable a números enteros .
El código de uso del operador condicional:
#include<stdio.h>
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);
int m = 0;
//(a>b) ? (m = a) : (m = b);
m = (a > b ? a : b);
/*if (a > b)
m = a;
else
m = b;*/
printf("%d\n", m);
return 0;
}
Es decir, cuando la expresión exp1 es verdadera, se ejecuta la expresión exp2; en caso contrario, se ejecuta la expresión exp3.
El código de uso de la expresión de coma:
#include<stdio.h>
int main()
{
int a = 3;
int b = 2;
int c = 5;
//逗号表达式，是从左向右依次计算的，逗号表达式的结果是最后一个表达式的结果
int d = (a+=3, b=5, c=a+b, c-4);
// a=6 b=5 c=11 7
printf("%d\n", d);
return 0;
}Operador unario:
| ！ | inversión lógica |
| - | valor negativo |
| + | valor positivo |
| & | tomar dirección |
| tamaño de | la longitud de tipo del operando en bytes |
| ~ | Inverso bit a bit de un número |
| -- | delantero trasero-- |
| ++ | Delantero, trasero++ |
| * | operador de acceso indirecto (operador de desreferencia) |
| (tipo) | elenco |
5. Palabras clave comunes
auto (automático) break case char const continue default do double else enum extern (declaración de símbolos externos) float for goto if int long register (registro) return short signed sizeof static struct switch typedef union (tipo de unión) unsigned void volatile whileC 语言提供了丰富的关键字，这些关键字都是语言本身预先设定好的，用户自己是不能创造关键字的。
1、关键字typedef
typedef 顾名思义是类型定义，这里应该理解为类型重命名。
代码：
//将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;
}2、关键字static
在 C 语言中：static 是用来修饰变量和函数的1. 修饰局部变量 - 称为静态局部变量2. 修饰全局变量 - 称为静态全局变量3. 修饰函数 - 称为静态函数
- 修饰局部变量
static 修饰局部变量的时候，本来一个局部变量是存放在栈区的，如果被static修饰就存储到静态区了，static 修饰局部变量改变了变量的存储类型(位置)，使得这个静态变量的生命周期变长了，直到程序结束才结束，但是作用域不变。
代码：
//代码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;
}
//运行结果为10个1
//代码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;
}
//运行结果为1 2 3 4 5 6 7 8 9 10- 修饰全局变量
全局变量具有外部链接属性，所以在其他源文件内部依然可以使用（方法要正确），static修饰全局变量，改变了这个全局变量的链接属性，由外边链接属性变成了内部链接属性，这个静态变量只能在自己所在的源文件内部使用，不能在其他源文件内部使用了，感觉像是作用域变小了。
代码：
//代码1
//add.c
int g_val = 2023;
//test.c
int main()
{
printf("%d\n", g_val);
return 0;
}
//代码2
//add.c
static int g_val = 2023;
//test.c
int main()
{
printf("%d\n", g_val);
return 0;
}代码1正常，代码2在编译的时候会出现连接性错误。
- 修饰函数
Una función estática modificada es lo mismo que una variable global estática modificada. La función tiene un atributo de enlace externo, pero si es modificada por estática, se convierte en un atributo de enlace interno, por lo que esta función solo se puede usar dentro del archivo fuente donde se encuentra y no se puede utilizar en otros Usado internamente por el archivo.
código:
//代码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 .
Aquí primero nos centraremos en explicar las dos palabras clave typedef y static .
6. #define define constantes y macros
Mire directamente el código para entender:
//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;
}Las macros definidas por #define son similares a las definiciones de funciones.
Macros definidas por #define:
#define ADD(x, y) ((x)+(y))
//ADD为宏的名字
//(x,y)中x,y是参数
//((x)+(y))是宏的实现体Definición de función:
int ADD(int x,int y)
{
return x+y;
}Esta vez, el resumen está aquí primero, y espero los gustos y el apoyo de mis amigos. ¡Su aliento es la fuerza que me impulsa a seguir adelante!