Table des matières
1. Chaîne + caractère d'échappement
6. #define définit les constantes et les macros
1. Chaîne + caractère d'échappement
1. Chaîne
Une chaîne de caractères entre guillemets doubles est appelée chaîne littérale ou chaîne en abrégé. En langage C, les tableaux de caractères sont généralement utilisés pour stocker des chaînes. (La marque de fin de la chaîne est un caractère d'échappement de \0 . Lors du calcul de la longueur de la chaîne, '\0' est la marque de fin et n'est pas compté comme le contenu de la chaîne.)
Le code suivant met en évidence la signification de '\0' dans les chaînes :
#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;
}Le résultat de son opération est :
A en juger par les résultats ci-dessus :
En comparant la sortie de la deuxième ligne avec la sortie de la troisième ligne, nous pouvons voir que lorsque la chaîne ne se termine pas par '\0', des valeurs aléatoires seront sorties plus tard. En l'absence de '\0' à la fin, la longueur 15 du tableau b en sortie dans la quatrième ligne est une valeur aléatoire.
Dans le code ci-dessus, la fonction strlen utilisée est une fonction de chaîne, qui est utilisée pour trouver la longueur de la chaîne, c'est-à-dire, à partir de l'adresse donnée, compter les caractères en arrière jusqu'à la fin de '\0', '\0' n'est pas inclus dans les statistiques.
Pour des fonctions de chaîne plus détaillées, vous pouvez lire cet article : http://t.csdn.cn/d321I
2. Caractères d'échappement
Tout d'abord, réfléchissons à ce problème, affichons un répertoire à l'écran : c:\code\test.c, comment doit-on écrire le code à ce moment ?
Essayons d'abord de sortir directement avec printf, le code est le suivant :
#include <stdio.h>
int main()
{
printf("c:\code\test.c\n");
return 0;
}Le résultat de son opération est :
Évidemment, ce n'est pas le résultat que nous voulons. Si nous voulons afficher le résultat correct, nous devons utiliser des caractères d'échappement à ce moment .
Le caractère d'échappement, comme son nom l'indique, sert à changer le sens. Certains caractères d'échappement sont répertoriés ci-dessous :
| caractère d'échappement | paraphrase |
| \ ? | Utilisé lors de l'écriture de plusieurs points d'interrogation à la suite, les empêchant d'être analysés en mots de trois lettres |
| \' | Utilisé pour représenter les constantes de caractère' |
| \" | Utilisé pour indiquer des guillemets doubles à l'intérieur d'une chaîne |
| \\ | Utilisé pour désigner une barre oblique inverse, l'empêchant d'être interprété comme une séquence d'échappement |
| \un | caractère d'avertissement, bip |
| \b | retour arrière |
| \F | Saut de formulaire |
| \n | nouvelle ligne |
| \r | retour chariot |
| \t | tabulation horizontale |
| \v | onglet vertical |
| \ddd | ddd représente 1 à 3 nombres octaux. Par exemple : \130 signifie le caractère X |
| \xdd | dd représente deux chiffres hexadécimaux. Par exemple : \x30 signifie le caractère 0 |
Les caractères d'échappement \ddd et \xdd doivent utiliser l'ASCLL et la conversion de base des caractères. Si vous n'êtes pas familier avec la table ASCLL, vous pouvez descendre par vous-même et enregistrer soigneusement les valeurs ASCLL des caractères couramment utilisés .
Puis imprimez un répertoire à l'écran : c:\code\test.c Le code correct est :
#include <stdio.h>
int main()
{
printf("c:\\code\\test.c\n");
return 0;
}Le résultat de l'opération est : 
Pour le caractère d'échappement \?, son code d'analyse est le suivant :
#include <stdio.h>
int main()
{
//\?是为了不让？被解析为三字母词
//三字母词 - ??) ——> ]
printf("%s\n","(are you ok\?\?)");
//输出结果为：(are you ok??)，否则结果为：(are you ok]
return 0;
}Regardons un exemple :
#include <stdio.h>
int main()
{
printf("%d\n", strlen("abcdef"));
// \x11和\62被解析成一个转义字符
printf("%d\n", strlen("c:\test\x11\628\test.c"));
return 0;
}Quelle devrait être la sortie du code ci-dessus ?
Le résultat est 6,15. La première sortie est facile à comprendre, c'est-à-dire le nombre de caractères, alors pourquoi la deuxième sortie est-elle de 15 ? La réponse est que \t, \x11 et \62 dans la chaîne sont tous des caractères d'échappement.
2. Remarques
Les commentaires sont de deux sortes :
-
Commentaires de style C /*xxxxxx*/, défaut : impossible d'imbriquer les commentaires
-
Commentaire de style C++ //xxxxxxxx, vous pouvez commenter une ligne ou plusieurs lignes
Par exemple:
#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. Tableau
Les tableaux sont définis en langage C comme suit : une collection d'éléments du même type.
1. Définition du tableau
int arr[10] = {1,2,3,4,5,6,7,8,9,10};//定义一个整形数组，最多放10个元素Le tableau arr, où les crochets [ ] peuvent également n'avoir aucune taille, la taille est déterminée en fonction du nombre d'éléments donné plus loin.
2. L'indice du tableau
Le langage C stipule que chaque élément du tableau a un indice, et l'indice commence à 0 . Les tableaux sont accessibles par abonnement.
Par exemple:
int arr[10] = {0};
//如果数组有10个元素全为0，下标的范围是0-9
3. L'utilisation de tableaux
code:
#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;
}Quatrièmement, l'opérateur
| opérateur arithmétique | + - * / % |
| opérateur de quart | >> << |
| opérateur au niveau du bit | & ^ | (comme l'opérateur de décalage, il fonctionne sur des bits binaires) |
| opérateur d'assignation | = += -= *= /= &= |= >>= <<= |
| opérateur relationnel | > >= < <= != == |
| opérateur logique | && (ET logique) || (OU logique) |
| opérateur conditionnel |
exp1
?
exp2 : exp3
|
| expression virgule |
exp1，
exp2 ，exp3，... expn
|
| Références d'indices et appels de fonction | [ ] ( ) |
| membre de structure | . -> |
/ Division en Opérateurs Arithmétiques :
- Le résultat du calcul est le quotient après divisibilité
- La division inclut la division entière et la division à virgule flottante. Dans la division à virgule flottante, au moins l'un des diviseur et dividende doit être un nombre à virgule flottante.
Opérateur modulo % : Le résultat est le reste, qui ne s'applique qu'aux entiers .
Le code d'utilisation de l'opérateur conditionnel :
#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;
}
Autrement dit, lorsque l'expression exp1 est vraie, l'expression exp2 est exécutée ; sinon, l'expression exp3 est exécutée.
Le code d'utilisation de l'expression virgule :
#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;
}Opérateur unaire :
| ！ | inversion logique |
| - | valeur négative |
| + | valeur positive |
| & | prendre l'adresse |
| taille de | la longueur du type de l'opérande en octets |
| ~ | Inverse binaire d'un nombre |
| -- | avant, arrière-- |
| ++ | Avant, arrière++ |
| * | opérateur d'accès indirect (opérateur de déréférencement) |
| (taper) | jeter |
5. Mots clés courants
auto (automatique) break case char const continue default do double else enum extern (déclaration de symboles externes) float for goto if int long registre (registre) return short signé sizeof static struct switch typedef union (type union) 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在编译的时候会出现连接性错误。
- 修饰函数
Une fonction modifiée statique est identique à une variable globale modifiée statique. La fonction a un attribut de lien externe, mais si elle est modifiée par statique, elle devient un attribut de lien interne, de sorte que cette fonction ne peut être utilisée qu'à l'intérieur du fichier source où il se trouve et ne peut pas être utilisé dans d'autres Utilisé en interne par le fichier.
code:
//代码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;
}Le code 1 est normal et le code 2 aura une erreur de connectivité lors de la compilation .
Ici, nous allons d'abord nous concentrer sur l'explication des deux mots-clés typedef et static .
6. #define définit les constantes et les macros
Regardez directement le code pour comprendre:
//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;
}Les macros définies par #define sont similaires aux définitions des fonctions.
Macros définies par #define :
#define ADD(x, y) ((x)+(y))
//ADD为宏的名字
//(x,y)中x,y是参数
//((x)+(y))是宏的实现体Définition de la fonction :
int ADD(int x,int y)
{
return x+y;
}Cette fois, le résumé est ici en premier, et j'attends avec impatience les likes et le soutien de mes amis. Vos encouragements sont la force motrice pour moi d'aller de l'avant !