C Syntaxe de base

Le langage C est un langage de programmation généraliste, largement utilisé dans des domaines tels que la programmation système, le développement embarqué et le calcul haute performance.

Le langage C présente des caractéristiques telles qu'une grande efficacité, une certaine flexibilité et une forte portabilité. Il est à la base de nombreux autres langages de programmation (comme C++, Java, Go) et reste le choix dominant pour le développement des systèmes d'exploitation, des pilotes et des bibliothèques de bas niveau.

En langage C, les jetons sont les éléments de base d'un programme. Le compilateur effectue une analyse lexicale du code source, en découpant le code en jetons individuels. Les jetons sont les plus petites unités significatives que le compilateur peut reconnaître, et l'ensemble du programme C est composé de ces jetons.

Les jetons en langage C comprennent principalement les types suivants :

• Mots-clés: mots réservés par le langage ayant des significations particulières, tels queint、if、return。
• Identificateurs: noms définis par les programmeurs, utilisés pour les variables, les fonctions, les tableaux, etc.
• Constantes: Valeurs dans un programme qui sont fixes et inchangées, telles que les entiers42, nombres à virgule flottante3.14。
• Littéraux de chaînes de caractères: séquences de caractères entre guillemets doubles, telles que"Hello"。
• Opérateurs: Symboles utilisés pour effectuer des opérations, tels que+、==、&&。
• Séparateurs: symboles utilisés pour séparer les instructions et les blocs de code, tels que;、{}。

Structure de base d'un programme C

Ceci est un programme simple en langage C qui peut afficher "Hello, World!" :

Le code ci-dessus se compose de la structure suivante :

• Directives de préprocesseur: telles que#includeet#define, traitées par le préprocesseur avant la compilation.
• fonction main: chaque programme C en a une et une seulemain()La fonction est le point d'entrée du programme.
• Déclaration de variable: déclare les variables utilisées dans le programme. C89 exige que les déclarations soient au tout début d'un bloc de code.
• Définition de fonction: définit les fonctions utilisées dans le programme, décrivant la logique d'implémentation spécifique des fonctions.

Une explication plus complexe de la structure d'un programme C (chaque point de connaissance sera développé dans les chapitres ultérieurs) :

Inclusion d'un fichier d'en-tête

• Les fichiers d'en-tête sont généralement utilisés au début d'un programme#includeLa directive include. Les fichiers d'en-tête fournissent les déclarations de fonctions et de bibliothèques, telles que la bibliothèque d'entrées/sorties standard<stdio.h>, bibliothèque standard<stdlib.h>etc. Ils définissent des fonctions, des macros, des constantes, etc., permettant au programme d'utiliser des fonctions de bibliothèque prédéfinies.
• Les fichiers d'en-tête système utilisent des chevrons<>, les fichiers d’en-tête personnalisés utilisent des guillemets doubles"", les deux ont des chemins de recherche différents.
• Exemple :#include <stdio.h>(fichiers d’en-tête système),#include "myheader.h"(fichiers d’en-tête personnalisés)

Définition de macro

• Une macro est implémentée par#defineConstantes symboliques ou extraits de code définis par des directives. Les macros sont remplacées textuellement par le préprocesseur avant la compilation, n’occupent pas de mémoire à l’exécution et sont souvent utilisées pour définir des constantes ou une logique de code en ligne simple.
• Les macros n’ont pas de vérification de type et doivent être utilisées avec prudence ; pour les constantes ayant des exigences de type, il est recommandé d’utiliserconstsubstitution de variable.
• Exemple :#define PI 3.14159、#define MAX(a, b) ((a) > (b) ? (a) : (b))

Déclaration de fonction

• En langage C, les déclarations de fonction (aussi appelées prototypes) doivent apparaître avant la définition ou l’appel de la fonction. La déclaration fournit le type de retour, le nom et la liste des paramètres de la fonction, afin que le compilateur puisse effectuer la vérification des types au point d’appel.
• Les déclarations de fonction peuvent être placées dans des fichiers d’en-tête pour être partagées entre plusieurs fichiers source.
• Exemple :int add(int a, int b);

fonction main

• main()La fonction est le point d’entrée d’un programme C. Tout programme C doit contenir unemain()fonction. Le programme démarre à partir demain()commence l'exécution, la valeur de retour est généralement0indique une exécution réussie du programme, et une valeur non nulle indique qu'une erreur s'est produite.
• main()Les fonctions peuvent aussi recevoir des arguments de ligne de commande :int main(int argc, char *argv[]), oùargcest le nombre de paramètres,argvest le tableau de chaînes d'arguments.
• Exemple :int main() { ... }

Déclaration de variable

• Dans les programmes C, toutes les variables doivent avoir leur type déclaré avant utilisation. Les variables peuvent êtremain()déclarées à l'intérieur des fonctions (variables locales), ou globalement à l'extérieur des fonctions (variables globales).
• Les variables peuvent être initialisées en même temps que leur déclaration. Les variables locales non initialisées contiennent des valeurs indéterminées (valeurs parasites), tandis que les variables globales et les variables statiques sont automatiquement initialisées à0。
• Exemple :int count = 0;、float price = 9.99;、char grade = 'A';

instructions et expressions

• Les instructions sont les unités d'exécution de base d'un programme C. Elles sont généralement des appels de fonction, des affectations et des instructions de contrôle (telles queif、foretc.) ou des expressions. Une expression est un fragment de code composé de variables, d'opérateurs et de constantes permettant de calculer une valeur.
• En langage C, l'affectation elle-même est aussi une expression et possède une valeur (c'est-à-dire la valeur affectée), vous pouvez donc écrirea = b = c = 0;une affectation chaînée comme ceci.
• Exemple :

  printf("Enter two integers: ");
  sum = add(num1, num2);

Instructions de contrôle de flux

• Les instructions de contrôle de flux servent à contrôler l'ordre d'exécution du programme, notamment les branchements conditionnels (if/else、switch) et les boucles (for、while、do-while). Il existe également des instructions de sautbreak、continue、gotoetreturn。
• Utiliser raisonnablement les instructions de contrôle de flux est la clé pour écrire des programmes à la logique claire, et leur abus doit être évité.gotopour préserver la lisibilité du code.
• Exemple :

  if (num1 > num2) {
      printf("num1 is greater than num2");
  }

Définition de fonction

• Une définition de fonction contient un corps de fonction complet et décrit l'implémentation spécifique de la fonction. Une fonction se compose d'un type de retour, d'un nom de fonction, d'une liste de paramètres et d'un corps de fonction. Une bonne conception de fonction doit suivre le principe de « responsabilité unique », chaque fonction ne faisant qu'une seule chose.
• Les fonctions du langage C ne prennent pas en charge la surcharge. Chaque nom de fonction doit être unique dans la même portée. Les fonctions peuvent s'appeler elles-mêmes récursivement.
• Exemple :

  int add(int a, int b) {
      return a + b;
  }

Instruction return

• returnL'instruction est utilisée pour terminer l'exécution d'une fonction et renvoyer le contrôle, ainsi que la valeur de retour, à l'appelant.voidLes fonctions de type peuvent utiliser un return sans valeurreturn;pour sortir plus tôt, ou peuvent omettrereturnl'instruction.
• main()La valeur de retour de la fonction est transmise au système d'exploitation,0indique généralement un succès, et la macro standard peut être utiliséeEXIT_SUCCESSetEXIT_FAILURE(définie dans<stdlib.h>）。
• Exemple :return 0;、return EXIT_SUCCESS;

Délimiteurs

Les séparateurs sont utilisés pour séparer les instructions, les expressions et les blocs de code, aidant le compilateur à comprendre la structure du programme. Les séparateurs courants incluent :

• virgule,: utilisée pour séparer plusieurs éléments dans les déclarations de variables, les paramètres de fonction ou les listes d'initialisation.
• Point-virgule;: utilisé pour terminer une instruction, et c'est le séparateur le plus courant du langage C.
• Crochets：
  • Parenthèses(): servent aux listes de paramètres des appels de fonction, aux conditions dans les instructions de contrôle de flux et à forcer l’ordre d’évaluation des expressions.
  • Accolades{}: servent à définir les corps de fonctions, les blocs de code de contrôle de flux et les initialisations de littéraux composés et de tableaux/structures.
  • Crochets[]: servent aux déclarations de tableaux et à l’accès aux éléments (opération d’indice).

Dans les programmes C, le point-virgule;est le terminateur d’instruction. Chaque instruction doit se terminer par un point-virgule, ce qui indique la fin d’une entité logique. Un point-virgule manquant est l’une des erreurs de syntaxe les plus courantes chez les débutants.

Par exemple, les deux instructions suivantes sont différentes :

printf("Hello, World! \n");
return 0;

Un point-virgule seul peut également être utilisé comme instruction vide, ce qui signifie qu’il ne fait rien. Il est souvent utilisé dans certaines structures de boucle :

while (condition);  // 空循环体，等待条件变化

Commentaires

Le langage C a deux façons de commenter :

// Single-line comment

avec//les commentaires monolignes commençant par (introduits par C99). Ce type de commentaire s’étend de//jusqu’à la fin de la ligne. Il peut occuper une ligne à lui seul ou être placé à la fin d’une ligne de code.

/* Single-line comment */
/* 
 Multi-line comment
 Multi-line comment
 Multi-line comment
 */

/* */Les commentaires dans ce format peuvent être sur une seule ligne ou sur plusieurs lignes, adaptés aux scénarios de commentaires plus longs tels que les descriptions de fonctions et les en-têtes de module.

Lors de l'utilisation des commentaires, tenez compte des points suivants :

• Les commentaires ne peuvent pas être imbriqués dans des commentaires (/* /* */ */est illégal).
• Les commentaires ne peuvent pas apparaître à l'intérieur de littéraux de chaîne ou de constantes de caractère.
• Les commentaires sont écrits pour que les gens les lisent. Ils doivent être concis et clairs, en se concentrant sur l'explication de "pourquoi" plutôt que de "ce qui a été fait" ; le code lui-même doit exprimer "ce qu'il fait".
• De bonnes habitudes de commentaire sont une partie importante de la programmation professionnelle, facilitant la maintenance du code et la collaboration en équipe.

Identificateurs

Les identificateurs sont les noms des variables, fonctions, tableaux, types, etc., dans un programme, définis par le programmeur. Les identificateurs sont composés de lettres (majuscules ou minuscules), de chiffres et de traits de soulignement, mais le premier caractère doit être une lettre ou un trait de soulignement, et non un chiffre.

Un identificateur commence par une lettre A-Z ou a-z ou un trait de soulignement _, suivi de zéro ou plusieurs lettres, traits de soulignement et chiffres (0-9).

Les caractères de ponctuation tels que @, $ et % ne sont pas autorisés dans les identificateurs C. C est un langage de programmationsensible à la casse. Par conséquent, en C,Manpoweretmanpowersont deux identificateurs différents. Ci-dessous figurent quelques identificateurs valides :

mohd       zara    abc   move_name  a_123
myname50   _temp   j     a23b9      retVal

Voici quelques exemples d'identificateurs invalides et les raisons :

2abc        // 错误：以数字开头
my-name     // 错误：包含连字符 -
float       // 错误：与关键字重名
my name     // 错误：包含空格

Suggestions de nommage : les identificateurs doivent être descriptifs et exprimer clairement leur objectif. Les styles de nommage courants incluent le nommage avec trait de soulignement (my_variable) et le nommage en lower camel case (myVariable), veillez simplement à rester cohérent dans le même projet. Les identificateurs commençant par un double trait de soulignement__sont généralement réservés par le compilateur ou la bibliothèque standard et doivent être évités dans le code utilisateur.

Constantes

Les constantes sont des valeurs fixes qui ne changent pas pendant l'exécution du programme. Il existe deux manières principales de définir des constantes en C : utiliserconstle mot-clé ou utiliser#definela définition de macro.

Les constantes peuvent être des constantes entières, des constantes à virgule flottante, des constantes de caractère, des constantes d'énumération, etc. :

const int MAX = 100;          // 整型常量
const float PI = 3.14159;    // 浮点型常量
const char NEWLINE = '\n';   // 字符常量（转义字符）

Les séquences d'échappement courantes dans les constantes de caractère incluent :

• \n: saut de ligne
• \t: tabulation horizontale
• \\: barre oblique inversée
• \': guillemet simple
• \0: caractère nul (marqueur de fin de chaîne)

UtilisationconstLes constantes définies avec possèdent des informations de type, ce qui permet au compilateur d'effectuer une vérification de type. Comparé à#defineLes macros sont plus sûres et constituent l'approche recommandée en C99 et versions ultérieures.

littéral de chaîne

Les littéraux de chaîne sont des séquences de caractères entourées de guillemets doubles, utilisées pour représenter des données textuelles.

Les littéraux de chaîne sont stockés en mémoire sous forme de tableaux de caractères, et un caractère nul est automatiquement ajouté à la fin\0(c'est-à-dire le terminateur nul), marquant la fin de la chaîne.

char greeting[] = "Hello, World!";  // 编译器自动计算长度（包含 \0）

Voici quelques notes importantes sur les littéraux de chaîne :

• "Hello" occupe en réalité 6 bytes en mémoire :'H'、'e'、'l'、'l'、'o'、'\0'。
• Les littéraux de chaîne sont stockés dans une mémoire en lecture seule et ne peuvent pas être modifiés ; si une modification est nécessaire, ils doivent être copiés dans un tableau de caractères.
• Deux littéraux de chaîne adjacents sont automatiquement concaténés par le compilateur :"Hello, " "World!"Équivalent à"Hello, World!"。
• Caractère'A'(constantes caractères) et les chaînes"A"(littéral de chaîne) sont différents ; ce dernier contient'A'et'\0'Deux caractères.

Opérateurs

Les opérateurs sont utilisés pour effectuer diverses opérations, telles que les opérations arithmétiques, logiques et de comparaison. Les opérateurs agissent sur des opérandes, forment des expressions et produisent des résultats.

Le langage C dispose d'une grande variété d'opérateurs. Les plus courants incluent :

• Opérateurs arithmétiques：+, -, *, /, %(où/effectue une division entière sur des entiers,%reste)
• Opérateurs relationnels：==, !=, >, <, >=, <=(renvoie 1 pour vrai, 0 pour faux)
• Opérateurs logiques：&&(ET),||(OU),!(NON), prend en charge l'évaluation en court-circuit
• Opérateurs bit à bit：&(ET bit à bit),|(OU bit à bit),^(OU exclusif bit à bit),~(NON bit à bit),<<(décalage à gauche),>>(décalage à droite)
• Opérateurs d'affectation：=, +=, -=, *=, /=, %=(affectation composée, telle quea += bÉquivalent àa = a + b）
• Opérateur d'incrémentation/décrémentation：++(incrémentation),--(décrémentation), qui possède deux formes : préfixe (décrémenter d'abord, puis évaluer) et postfixe (évaluer d'abord, puis décrémenter)
• Autres opérateurs：sizeof(calcule la taille en octets d'un type ou d'une variable),?:(opérateur ternaire),&(adresse de),*(déréférencement),->(accès aux membres via un pointeur),.(accès direct aux membres)

int a = 5, b = 10;
int sum = a + b;           // 算术运算符 +，sum = 15
int isEqual = (a == b);   // 关系运算符 ==，isEqual = 0（假）
int result = a << 1;      // 位运算左移，result = 10（相当于 a * 2）
a++;                       // 后缀自增，a 变为 6
int max = (a > b) ? a : b; // 三目运算符，max = b = 10

Les opérateurs ont une priorité et une associativité : la priorité détermine l'ordre des opérations, et l'associativité détermine le sens d'évaluation des opérateurs de même niveau. En cas de doute sur la priorité, il est recommandé d'utiliser des parenthèses pour un regroupement explicite afin d'améliorer la lisibilité du code.

Mots-clés

Le tableau suivant répertorie les mots réservés du C. Ces mots réservés ne peuvent pas être utilisés comme noms de constantes, noms de variables ou autres noms d'identificateurs ; ils ont des significations syntaxiques spécifiques dans le langage C.

Nouveaux mots-clés en C99

Le mot-clé ajouté en C99 sert principalement à : la prise en charge du type booléen (_Bool), la prise en charge des nombres complexes (_Complex、_Imaginary), optimisation des fonctions inline (inline), optimisation de restriction d'alias de pointeur (restrict）。

Nouveaux mots-clés en C11

Le mot-clé ajouté en C11 est principalement utilisé pour : contrôle d'alignement mémoire (_Alignas、_Alignof), opérations atomiques et prise en charge du multithreading (_Atomic、_Thread_local), sélection générique (_Generic), assertion statique (_Static_assert) et marquage des fonctions sans valeur de retour (_Noreturn）。

Espaces blancs en C

Une ligne ne contenant que des espaces est appelée ligne vide ; elle peut contenir un commentaire, et le compilateur C l'ignorera complètement.

En C, les espaces blancs servent à désigner l'espace (touche espace), la tabulation (Tab), le saut de ligne et les commentaires. Les espaces séparent les parties d'une instruction, ce qui permet au compilateur d'identifier où se termine un élément de l'instruction (tel queint) et où commence l'élément suivant. Par conséquent, dans l'instruction suivante :

int age;

intetageIl doit y avoir au moins un caractère d'espacement (généralement un espace blanc) entre eux pour que le compilateur puisse les distinguer. En revanche, dans l'instruction suivante :

fruit = apples + oranges;   // 获取水果的总数

fruitet=, ou=etapplesLe caractère d'espacement entre eux n'est pas requis, mais pour améliorer la lisibilité, vous pouvez ajouter des espaces si nécessaire.

De bonnes habitudes d'espacement et d'indentation sont une partie importante d'un code de haute qualité ; il est recommandé de suivre les conventions suivantes :

• Utilisez une indentation cohérente (généralement 4 espaces ou 1 tabulation) pour indiquer la hiérarchie des blocs de code.
• Ajoutez des espaces des deux côtés des opérateurs (par ex.a + b), ce qui rend les expressions plus faciles à lire.
• Ajoutez un espace après les virgules (par ex.int a, b, c;), pour distinguer plusieurs éléments.
• Utilisez des lignes vides de manière appropriée pour séparer les sections de code logiquement liées, ce qui améliore la lisibilité globale.