＜Langage C＞ Langage C initial

1 Qu'est-ce que le langage C ?

面向过程Le langage C est un langage de programmation informatique à usage général . Il a été développé par Dennis Ritchie aux laboratoires Bell vers 1972 et est devenu un langage largement utilisé dans la programmation de systèmes et le développement d'applications. Le langage C a une syntaxe concise, une vitesse d'exécution efficace et de puissantes capacités de contrôle sous-jacentes, il est donc largement utilisé dans les systèmes d'exploitation, les systèmes embarqués, le développement de jeux et d'autres domaines.

ANSI CDans les années 1980, afin d'éviter les différences dans la grammaire du langage C utilisée par divers développeurs, le US National Bureau of Standards a formulé un ensemble complet de grammaires American National Standard pour le langage C, connu comme la norme originale du langage C.

Le langage C est un 面向过程langage de programmation informatique, différent des langages de programmation orientés objet tels que C++ et Java. Ses compilateurs incluent principalement Clang, GCC, WIN-TC, SUBLIME, MSVC (VS), Turbo C, etc.

2 Le premier programme en langage C

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

expliquer:

#include <stdio.h>Cette ligne de code est une directive de prétraitement qui indique au compilateur d'inclure les fichiers d'en-tête pour les fonctions d'entrée et de sortie standard stdio.h. Le fichier d'en-tête contient des prototypes de fonction et des définitions constantes pour les opérations d'entrée et de sortie.

La fonction principale du programme main, qui est le point d'entrée du programme en langage C. intEst le type de retour de la fonction, mainest le nom de la fonction et les parenthèses vides après indiquent que la fonction n'accepte aucun paramètre. Il doit y avoir une fonction principale, et il ne peut y en avoir qu'une.

Une fonction dans la bibliothèque standard du langage C printf, qui est utilisée pour générer la chaîne de format spécifiée sur la sortie standard (généralement la console). Ici, nous transmettons la chaîne "Hello World" comme argument à printfla fonction et elle imprimera cette chaîne sur la console.

return 0, qui indique la fin de la fonction et renvoie la valeur entière 0 à l'appelant comme valeur de retour de la fonction. En langage C, une valeur de retour de 0 indique généralement que le programme s'est exécuté avec succès.

\nest un caractère d'échappement spécial appelé saut de ligne. Il est utilisé pour indiquer une opération de retour à la ligne dans la sortie, c'est-à-dire pour déplacer le curseur de sortie au début de la ligne suivante.

2.1 fonction printf

printfEst une fonction de la bibliothèque standard du langage C, qui est utilisée pour formater le texte de sortie sur la sortie standard (généralement la console). ``

Prototype de fonction :

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

printfLa fonction principale de la fonction est de formater le paramètre correspondant dans le texte spécifié en fonction de l'espace réservé dans la chaîne de format, et de le sortir sur la sortie standard. La valeur de retour de la fonction est le nombre de caractères imprimés. Les espaces réservés %commencent par et sont suivis d'un ou plusieurs caractères qui spécifient le type d'argument et le format de la sortie.

Les espaces réservés de formatage courants et leur utilisation sont les suivants :

%d: Sort un entier décimal signé.
%u: Sort un entier décimal non signé.
%f: nombre à virgule flottante de sortie.
%c: Sortie d'un seul caractère.
%s: chaîne de sortie.
%p: Adresse du pointeur de sortie.
%xOu %X: affiche un entier hexadécimal.

Les caractères ordinaires de la chaîne de format sont sortis tels quels, à l'exception des espaces réservés.

Dans printfla fonction, vous pouvez définir la précision, la largeur et le remplissage de la sortie à l'aide des options de formatage. Voici quelques options de formatage couramment utilisées :

1. Précision (Precision) : utilisé pour spécifier la précision de sortie des nombres à virgule flottante ou des chaînes.

%.nf: définit la précision du nombre à virgule flottante après la virgule décimale sur n chiffres.
%.*f: Spécifiez la précision après la virgule décimale du nombre à virgule flottante via une variable, par exemple %.*f, passez un paramètre entier n plus tard pour spécifier la valeur de la précision.

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

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

2. Largeur : Il est utilisé pour spécifier la largeur du champ de sortie, qui peut être rempli d'espaces ou d'autres caractères.

%nd: définissez la largeur de sortie de l'entier sur n caractères et remplissez la partie insuffisante avec des espaces.
%*d: Spécifiez la largeur de sortie d'un entier via une variable, par exemple %*d, passez un paramètre entier n plus tard pour spécifier la valeur de la largeur.

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

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

3. Caractère de remplissage (Padding Character) : utilisé pour spécifier le caractère pour remplir le champ de sortie, la valeur par défaut est un espace.

%nd: Ajoutez des caractères de remplissage avant la largeur de sortie n de l'entier, par exemple %6d, définissez la largeur de l'entier de sortie sur 6 caractères et complétez avec des espaces par défaut.
%*cd: Spécifiez le caractère de remplissage via une variable, par exemple %*cd, passez un paramètre de caractère c ultérieurement pour spécifier la valeur du caractère de remplissage.

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

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

2.2 fonction scanf

scanfest une fonction de la bibliothèque standard du langage C pour lire les données d'entrée à partir de l'entrée standard (généralement le clavier).

Prototype de fonction :

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

valeur de retour :

scanfLa fonction renvoie le nombre d'éléments de données lus avec succès, ou un nombre négatif si une erreur s'est produite ou si la fin de la saisie a été atteinte.

scanfSelon les espaces réservés dans la chaîne de format, la fonction lit les données correspondantes à partir de l'entrée standard et les stocke dans la variable spécifiée.

Les espaces réservés de formatage courants et leur utilisation sont les suivants :

%d: Lire un entier décimal signé.
%u: Lire un entier décimal non signé.
%f: Lire un nombre à virgule flottante.
%c: Lire un seul caractère.
%s: Lire une chaîne.
%p: Lire l'adresse du pointeur.
%xOu %X: lire un entier hexadécimal.

À l'exception des espaces réservés, les caractères ordinaires de la chaîne formatée seront mis en correspondance avec les données d'entrée, et les caractères correspondants doivent être entrés pour correspondre avec succès.

scanfLa fonction prend des entrées en fonction de la chaîne de format et des paramètres correspondants. Si les données d'entrée ne correspondent pas aux espaces réservés dans la chaîne de format, cela peut entraîner des erreurs de saisie ou des erreurs d'exécution. Par conséquent, lorsque vous utilisez scanfla fonction, vous devez vous assurer que la chaîne de format et les paramètres correspondent correctement pour éviter les problèmes potentiels.

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

3 types de données de base

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

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

La taille du type de données dépend du compilateur et de l'implémentation de la plate-forme cible. Le compilateur détermine les tailles des différents types de données en fonction de la spécification standard du langage C et des caractéristiques de la plate-forme cible.

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

Certaines valeurs dans la vie sont constantes (par exemple : pi, sexe, numéro d'identification, groupe sanguin, etc.)

Certaines valeurs sont variables (ex : âge, poids, salaire).

Les variables sont des identifiants utilisés pour stocker et manipuler des données variables. Dans un programme, nous pouvons déclarer une variable et lui allouer de l'espace mémoire, puis nous pouvons consulter et modifier la valeur stockée en mémoire via le nom de la variable. La valeur d'une variable peut changer pendant l'exécution du programme.

Les constantes sont des valeurs fixes qui ne peuvent pas être modifiées. Dans les programmes, nous pouvons utiliser des constantes pour représenter des valeurs immuables telles que des nombres, des caractères ou des chaînes. La valeur d'une constante est déterminée lors de sa définition et ne peut pas être modifiée.

Les variables sont utilisées pour stocker et manipuler des données modifiables dont la valeur peut changer pendant l'exécution du programme.

Une constante permet de représenter une valeur fixe immuable dont la valeur est déterminée au moment de la définition et ne peut plus être modifiée.

4.1 Méthode de définition des variables

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

4.2 Dénomination des variables

Ne peut être composé que de lettres (majuscules et minuscules), de chiffres et de traits de soulignement ( _ ).

Ne peut pas commencer par un chiffre.

Ne peut pas dépasser 63 caractères.

Les noms de variables sont sensibles à la casse.

Les noms de variables ne peuvent pas utiliser de mots clés.

4.3 Classement des variables

variable locale
variable globale

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

Il n'y a en fait rien de mal avec la définition de la variable globale variable locale ci-dessus !

Lorsqu'une variable locale porte le même nom qu'une variable globale, la variable locale est prioritaire.

Utilisation 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 La portée et le cycle de vie des variables

En langage C, la portée des variables (scope) et la durée de vie (lifetime) sont des concepts qui décrivent la visibilité et le temps d'existence des variables dans le programme.

Portée (Portée) fait référence à la plage visible de variables dans le programme. Les variables ont une accessibilité différente dans différentes portées. Il existe plusieurs portées en langage C :

Portée du bloc : une variable est déclarée dans un bloc de code (entouré d'accolades {}) et est visible à l'intérieur de ce bloc. Une fois que vous quittez le bloc, la variable sort de sa portée.

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

Portée de la fonction : les variables sont déclarées dans une fonction et sont visibles dans toute la fonction. Les paramètres de fonction et les variables déclarées à l'intérieur des fonctions ont une portée de fonction.

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

Portée du fichier (portée globale) (Portée du fichier) : les variables sont déclarées dans tout le fichier source et sont accessibles par n'importe quelle fonction du fichier. Les variables déclarées en dehors d'une fonction ont une portée de fichier.

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

La durée de vie fait référence à la plage de temps dans laquelle une variable existe. La durée de vie d'une variable dépend de sa portée et de la façon dont elle est déclarée. Il existe les cycles de vie variables suivants en langage C :

Variables automatiques (Automatic Variables) : Les variables déclarées à l'intérieur des fonctions sont des variables automatiques. Leur cycle de vie commence à la définition de la variable et se termine à la fin du bloc de code dans lequel elles sont contenues. Les variables sont recréées chaque fois qu'un bloc de code est saisi et détruites lorsque le bloc de code est quitté.

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

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

Variables statiques (Static Variables)static : Les variables déclarées à l'aide du mot clé à l'intérieur d'une fonction sont des variables statiques. Leur durée de vie commence lorsque le programme commence à s'exécuter et se termine lorsque le programme se termine. Les variables statiques existent tout au long de l'exécution du programme et ne sont initialisées qu'une seule fois.

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

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

Variables globales : Les variables déclarées en dehors d'une fonction sont des variables globales. Leur durée de vie commence lorsque le programme commence à s'exécuter et se termine lorsque le programme se termine. Les variables globales existent tout au long de l'exécution du programme et ne sont initialisées qu'une seule fois.

int globalVar;  // 全局变量

void function() {
    
    
    globalVar = 10;
}

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

4.5 Constantes

Les formes de définition des constantes et des variables en langage C sont différentes.

Les constantes en langage C sont réparties dans les catégories suivantes :

constante littérale
constvariable constante modifiée
#defineConstantes d'identification définies
constante d'énumération

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

L'exemple ci-dessus paiest appelé une constvariable constante modifiée. constUne variable constante modifiée en langage C ne limite la variable qu'au niveau grammatical et paine peut pas être directement modifiée, mais paiil s'agit toujours d'une variable par essence, c'est pourquoi on l'appelle une variable constante.

5 chaîne + caractère d'échappement + commentaire

5.1 Chaînes

"hello bit.\n"

Cette chaîne de caractères entourée de guillemets doubles (Double Quote) est appelée une chaîne littérale (String Literal), ou simplement une chaîne.

Remarque : La fin de la chaîne est un caractère d'échappement \0. \0 est la marque de fin lors du calcul de la longueur de la chaîne, et elle n'est pas comptée comme le contenu de la chaîne.

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

arr1est un tableau de caractères initialisé sous forme de chaîne. Il contient les caractères 'b', 'i', 't' et le caractère nul '\0', et le caractère nul est automatiquement ajouté à la fin du tableau. Par conséquent, printf("%s\n", arr1)ce qui est imprimé est la chaîne complète "bit".
arr2est un tableau de caractères initialisé avec une liste de caractères. Il contient les caractères 'b', 'i', 't', mais n'ajoute pas le caractère nul '\0' à la fin. Étant donné que %sle format nécessite une chaîne terminée par un caractère nul, printf("%s\n", arr2)continue d'accéder arr2à la mémoire jusqu'à ce que le premier caractère nul soit rencontré. Le contenu de la mémoire derrière ici n'est pas défini, donc le résultat imprimé n'est pas défini.
arr3est un tableau de caractères initialisé avec une liste de caractères, avec le caractère nul '\0' explicitement ajouté à la fin. Par conséquent, printf("%s\n", arr3)ce qui est imprimé est la chaîne complète "bit".

Une chaîne en langage C est un tableau de caractères terminé par un caractère nul '\0', qui marque la fin de la chaîne. Si la chaîne ne se termine pas par un caractère nul, les fonctions de gestion de chaîne (telles que printf, strcpy, strlenetc.) ne traiteront pas la chaîne correctement et peuvent provoquer des résultats inattendus ou des erreurs. Par conséquent, lors de la manipulation de chaînes, il est très important de s'assurer que les chaînes se terminent par un caractère nul '\0'.

5.2 Caractères d'échappement

Si nous voulons imprimer un répertoire à l'écranc:\code\test.c

Comment écrire du code ?

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

Ici, je dois mentionner le caractère d'échappement. Le caractère d'échappement, comme son nom l'indique, sert à changer le sens.

Regardons quelques caractères d'échappement.

\n: nouvelle ligne (nouvelle ligne)
\t: caractère de tabulation (tabulation)
\": guillemets doubles (guillemets doubles)
\': apostrophe (guillemet simple)
\\: antislash (antislash)
\b: retour arrière
\r: retour chariot
\f: saut de page (saut de page)
\v: onglet vertical (onglet vertical)
\a: symbole cloche (alerte)
\0: caractère nul
\?: point d'interrogation (point d'interrogation)
\ooo: caractère octal (où oooreprésente un nombre octal, la plage est \000de \377)
\xhh: Caractère hexadécimal (où hhreprésente un nombre hexadécimal, la plage est \x00de \xFF)

Il convient de noter que si une séquence de caractères d'échappement inconnue est utilisée dans un littéral de chaîne, ou si un nombre octal ou hexadécimal hors plage est utilisé dans un littéral de caractère, le compilateur peut signaler une erreur ou générer un comportement défini. Par conséquent, lorsque vous utilisez des caractères d'échappement, assurez-vous de comprendre leur syntaxe et leur signification correctes.

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

Question stylo :

//程序输出什么？
#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 Remarques

Le code inutile dans le code peut être supprimé directement ou commenté
Certains codes dans le code sont difficiles à comprendre, vous pouvez ajouter un texte de commentaire

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

Les commentaires sont de deux sortes :

Commentaires de style C/*xxxxxx*/
- Inconvénient : impossible d'imbriquer les commentaires
Commentaires de style C++//xxxxxxxx
- Vous pouvez commenter une ligne ou plusieurs lignes

6. Mots clés courants

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

Le langage C fournit une multitude de mots-clés, qui sont prédéfinis par le langage lui-même, et les utilisateurs ne peuvent pas créer de mots-clés par eux-mêmes.

6.1 Typedefs des mots clés

typedef, comme son nom l'indique, est une définition de type, et ici il doit être compris comme un renommage de type.

Par exemple:

//将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 Mot clé statique

En langage C : static est utilisé pour modifier des variables et des fonctions

Décorer les variables locales - appelées variables locales statiques

Décorer les variables globales - appelées variables globales statiques

Fonctions de décoration - appelées fonctions statiques

Modifier les variables locales

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

Résultat de sortie :

1 1 1 1 1 1 1 1 1 1

Ajouter statique :

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

Résultat de sortie :

1 2 3 4 5 6 7 8 9 10

Comparez l'effet du code 1 et du code 2 pour comprendre l'importance de la modification statique des variables locales.

en conclusion:

La modification statique des variables locales modifie le cycle de vie des variables

Laissez les variables locales statiques exister toujours en dehors de la portée, et le cycle de vie ne se terminera qu'à la fin du programme.

Décorer les variables globales

Exemple:

//代码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;
}

Le code 1 est normal et le code 2 aura une erreur de connectivité lors de la compilation.

en conclusion:

Une variable globale est modifiée par static, de sorte que cette variable globale ne peut être utilisée que dans ce fichier source et ne peut pas être utilisée dans d'autres fichiers source.

fonction modificateur

Exemple:

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

en conclusion:

Une fonction est modifiée par static, de sorte que cette fonction ne peut être utilisée que dans ce fichier source et ne peut pas être utilisée dans d'autres fichiers source.

7. #define définit les constantes et les 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;
}