Introduction aux bases du langage C

Beaucoup de gens, lors de leur premier contact avec le langage C, le trouvent un peu « rigide ».

Il n'y a pas beaucoup d'encapsulations toutes faites, ni beaucoup de sucre syntaxique, et il faut souvent tout écrire soi-même, étape par étape.

Mais c'est justement pour cette raison que le langage C est particulièrement adapté pour poser des bases solides.

Il vous oblige à comprendre : ce qu'est réellement une variable, pourquoi il faut passer une adresse pour une saisie, comment les tableaux peuvent coopérer avec les boucles, comment passer des paramètres à une fonction, et pourquoi les pointeurs sont toujours incontournables.

Si ces notions les plus fondamentales sont vraiment bien comprises, que vous continuiez ensuite à apprendre le C++, Java, Python, ou que vous abordiez les systèmes d'exploitation, l'embarqué ou les structures de données, votre compréhension sera plus solide.

Cet article relie les bases fondamentales du langage C dans l'ordre le plus facile à appréhender pour un débutant, afin de vous aider à construire un cadre de connaissances complet.

I. Pour apprendre le C, saisissez d'abord trois axes principaux

L'erreur la plus fréquente quand on commence à apprendre le C est de l'étudier comme on apprendrait du « par cœur ».

Aujourd'hui on mémorise un if, demain un for, après-demain on apprend par cœur scanf, les tableaux, les pointeurs.

On a l'impression d'apprendre beaucoup, mais en réalité, c'est le bazar dans la tête.

Une meilleure approche consiste à saisir d'abord trois axes principaux :

Premièrement, comment les données sont stockées.

Les variables, les tableaux, les structures, les chaînes de caractères, tout cela répond essentiellement à la question « où placer l'information ».

Deuxièmement, comment le programme contrôle le flux d'exécution.

L'exécution séquentielle, les branchements conditionnels, les répétitions par boucles, tout cela répond à la question « comment faire les choses étape par étape ».

Troisièmement, comment le programme trouve les données.

Cela traverse scanf, le passage de paramètres aux fonctions, les tableaux, les pointeurs, et même les opérations sur les fichiers.

Tant que vous apprenez en suivant ces trois axes, de nombreux points de connaissance apparemment épars se connecteront naturellement.

II. Les variables : pourquoi un programme peut « se souvenir » des données

Pour traiter des données, un programme doit d'abord pouvoir les stocker.

Et la variable est l'« unité de stockage » la plus fondamentale dans un programme.

Par exemple :

int age = 18;

Cette ligne de code signifie : définir une variable de type entier nommée age et y stocker la valeur 18.

Deux concepts de base doivent d'abord être clarifiés ici :les identifiantsetles types de données.

1. Identifiants : donner un nom aux données

Les noms de variables, de fonctions et de tableaux sont collectivement appelés identifiants.

Un identifiant ne s'écrit pas n'importe comment, il doit respecter des règles de base :

• Composé de lettres, chiffres et du caractère de soulignement
• Ne peut pas commencer par un chiffre
• Ne peut pas être un mot-clé réservé
• Sensible à la casse

Par exemple :

int score;
int _num;
int age1;

Ces écritures sont toutes valides.

Mais les suivantes sont illégales :

int 2a;
int if;

Donc, la première étape pour apprendre à définir une variable est en fait d'apprendre à donner un nom légal et clair aux données.

2. Types de données : déterminent ce qu'une variable peut contenir

En langage C, on ne peut pas « prendre n'importe quelle variable pour y mettre n'importe quoi », chaque variable doit d'abord être déclarée avec un type.

Les types de base courants sont :

int a = 10;       // 整数
float b = 3.14;   // 浮点数
char c = 'A';     // 字符

Cela signifie qu'une variable a non seulement un nom, mais aussi une restriction sur « ce que cette boîte est autorisée à contenir ».

Il est essentiel de prendre conscience de cela dès le début de l'apprentissage, car cela influencera toute votre compréhension ultérieure des entrées, sorties, opérations et de la mémoire.

III. Entrées et sorties : comment le programme interagit avec l'utilisateur

Un programme ne se contente pas de calculer en interne, il doit aussi interagir avec les gens.

Les modes d'interaction les plus courants sont l'entrée et la sortie.

1. Sortie : afficher les résultats

La fonction de sortie la plus courante en C est printf.

Par exemple :

printf("Hello C!\n");

Pour afficher une variable, il faut utiliser un spécificateur de format :

int age = 18;
printf("%d\n", age);

Ici, %d signifie « afficher au format entier ».

Les spécificateurs de format courants sont :

• %d : entier
• %f : nombre à virgule flottante
• %c : caractère
• %s : chaîne de caractères

Par exemple :

float price = 19.9;
char ch = 'A';

printf("%f\n", price);
printf("%c\n", ch);

Le plus important avec printf

n'est pas d'apprendre les symboles par cœur, mais de comprendre que : lorsqu'un programme sort des données, il doit savoir selon quel type les interpréter.

2. Entrée : pourquoi scanf est souvent accompagné de &

Si printf sert à « afficher le contenu », alors scanf sert à « lire ce que l'utilisateur saisit ».

Par exemple :

int age;
scanf("%d", &age);

Cette ligne de code signifie : lire un entier depuis le clavier et le stocker dans la variable age.

Certains pourraient se demander pourquoi on écrit &age ici, et non pas age ?

La raison est simple :

scanf n'a pas besoin de lire la valeur actuelle de age, mais doit « écrire le contenu saisi par l'utilisateur à l'emplacement où se trouve age ».

Il n'a donc pas besoin de la valeur, mais de l'adresse.

C'est-à-dire :

• age représente la valeur contenue dans la variable
• &age représente l'adresse de la variable en mémoire

Ce & vous a en réalité déjà introduit à la pensée fondamentale la plus centrale du langage C :

le programme ne traite pas seulement des valeurs, mais aussi l'emplacement où se trouvent ces valeurs.

IV. Opérateurs et expressions : comment le programme « calcule »-t-il exactement ?

Une fois les variables, les entrées et les sorties en place, le programme doit ensuite commencer à traiter les données.

Et pour traiter les données, on ne peut pas se passer des opérateurs et des expressions.

1. Opérateurs arithmétiques

Les opérateurs arithmétiques les plus basiques sont :

+  -  *  /  %

Par exemple :

int a = 10;
int b = 3;

printf("%d\n", a + b);
printf("%d\n", a % b);

Parmi eux, ceux qui méritent le plus l'attention des débutants sont / et %.

Division entière

Si les deux opérandes sont des entiers :

15 / 4

Le résultat est 3, et non 3.75.

Car la division entière ne conserve que la partie entière.

Division flottante

Dès qu'un des opérandes est un nombre à virgule flottante :

15 / 4.0

Le résultat devient alors 3.75.

Opération modulo

15 % 4

Le résultat est 3, représentant le reste.

% ne peut être utilisé qu'avec des entiers, mais il est très pratique.

On l'utilise souvent pour déterminer la parité, décomposer des nombres ou traiter des motifs cycliques.

2. Affectation composée

Au lieu de :

a = a + 3;

On peut aussi écrire :

a += 3;

De manière similaire, il y a aussi :

a -= 3;
a *= 3;
a /= 3;
a %= 3;

Ces écritures sont particulièrement courantes dans les boucles et le traitement des tableaux.

3. Opérations logiques

Les opérateurs logiques servent à combiner plusieurs conditions :

• ! : NON
• && : ET
• || : OU

Par exemple :

if (age >= 18 && age <= 60)
{
    printf("符合条件\n");
}

Ainsi, le programme n'est pas limité à juger une seule condition, il peut aussi en combiner plusieurs pour prendre une décision.

V. Branchements : apprendre au programme à « faire des choix »

Dans les problèmes réels, beaucoup de choses ne se font pas simplement en séquence, mais plutôt « si une certaine condition est remplie, exécuter A ; sinon, exécuter B ».

C'est le rôle des structures de branchement.

1. if : le jugement conditionnel le plus basique

Par exemple :

if (x > 0)
{
    printf("x是一个正数");
}
else
{
    printf("x不是一个正数");
}

Ce type de code est presque une traduction directe du langage naturel :

• si la condition est vraie, exécuter le bloc de code précédent
• sinon, exécuter le bloc de code suivant

2. Branchements multiples

S'il y a plus de cas, on peut étendre avec else if :

if (score >= 90)
    printf("A");
else if (score >= 80)
    printf("B");
else if (score >= 70)
    printf("C");
else if (score >= 60)
    printf("D");
else
    printf("E");

Cette structure est particulièrement adaptée pour traiter des « règles par paliers », comme la classification des notes, le calcul de frais, ou la répartition par âge.

3. switch : plus clair pour traiter des valeurs fixes

Si la condition de jugement est « à quelle valeur fixe cette variable est-elle égale », switch sera plus ordonné :

switch (grade)
{
case 'A':
    printf("优秀");
    break;
case 'B':
    printf("良好");
    break;
default:
    printf("其他");
}

Le point le plus crucial ici est le break.

Si on oublie de l'écrire, le programme continuera à exécuter les cas suivants, produisant un effet de « traversée ».

VI. Boucles : apprendre au programme à répéter des actions

Si les branchements servent à « faire des choix », les boucles servent à « répéter des actions ».

L'une des choses que l'ordinateur fait le mieux est d'exécuter précisément le même ensemble de règles de nombreuses fois.

Et la boucle est précisément la manifestation de cette capacité.

1. while : exécuter tant que la condition est vraie

int i = 1;
while (i <= 5)
{
    printf("%d\n", i);
    i++;
}

Ce code affichera les nombres de 1 à 5.

La caractéristique de while

est : d'abord évaluer la condition, puis exécuter. Ainsi, si la condition est fausse dès le départ, la boucle peut ne pas être exécutée du tout.

2. do...while : exécuter au moins une fois d'abord

int i = 1;
do
{
    printf("%d\n", i);
    i++;
} while (i <= 5);

Contrairement à while, do...while exécute d'abord le corps une fois, puis évalue la condition.

3. for : la boucle de comptage la plus utilisée

for (int i = 1; i <= 5; i++)
{
    printf("%d\n", i);
}

La boucle for

regroupe l'initialisation, la condition et la mise à jour sur une seule ligne, ce qui rend la structure plus compacte, et elle est donc très courante en programmation pratique.

4. La véritable valeur des boucles

• Les tâches de boucle les plus courantes au début de l'apprentissage incluent :
• Faire une somme
• Compter des éléments
• Trouver le maximum et le minimum
• Parcourir un tableau

Afficher les nombres dans un intervalle qui satisfont une condition

Ainsi, la boucle n'est pas un simple modèle syntaxique, mais une façon de penser la programmation très importante : décomposer un problème en un processus de « répétition d'un même ensemble d'étapes ».

VII. Fonctions : encapsuler un bloc fonctionnel

Quand le programme devient de plus en plus long, mettre tout le code dans le main devient très désordonné.

C'est là que les fonctions sont nécessaires.

On peut comprendre une fonction comme :

un bloc de code dédié à l'accomplissement d'une tâche spécifique, et qui peut être appelé de manière répétée.

Par exemple :

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

Lors de l'appel, on écrit :

int sum = add(10, 20);
printf("%d", sum);

1. Pourquoi les fonctions sont importantes

Les fonctions ont deux valeurs fondamentales :

• Décomposer un programme complexe pour rendre la structure plus claire
• Encapsuler la logique répétitive pour éviter de réécrire le même code

2. Paramètres et valeur de retour

Les paramètres d'une fonction servent à transmettre des données à l'intérieur.

La valeur de retour sert à ramener un résultat à l'extérieur.

Ces deux concepts semblent simples, mais ils déterminent presque tout le sens d'une fonction.

3. Passage par valeur et passage par adresse

C'est une étape très cruciale lors de l'apprentissage des fonctions.

Le passage de paramètres ordinaire consiste essentiellement à copier la valeur pour la fonction.

Même si la fonction modifie le paramètre en interne, cela n'affecte pas nécessairement la variable externe.

Si c'est une adresse qui est passée, la situation est différente.

La fonction peut, via cette adresse, manipuler directement l'emplacement mémoire où se trouve la variable externe.

C'est aussi pourquoi il existe un lien très fort entre les fonctions, scanf et les pointeurs.

4. Tableau comme paramètre de fonction

Le passage de tableau en paramètre mérite une attention particulière.

Car lorsqu'un tableau est passé en paramètre à une fonction, c'est essentiellement l'adresse de son premier élément qui est transmise.

Cela signifie que les modifications des éléments du tableau à l'intérieur de la fonction affecteront souvent directement le tableau original.

Ce point est très important pour comprendre le « passage par adresse ».

VIII. Tableaux : quand une seule variable ne suffit pas

Si le programme ne traite qu'un seul nombre, une variable suffit.

Mais s'il faut traiter 10 notes, 5 coordonnées, ou la liste des scores d'une classe, une seule variable n'est clairement pas suffisante.

C'est là qu'on utilise les tableaux.

1. Tableau unidimensionnel : un ensemble de données du même type

int arr[5] = {1, 2, 3, 4, 5};

Ceci définit un tableau contenant 5 entiers.

L'essence d'un tableau peut être comprise comme :

placer un ensemble de données du même type les unes à la suite des autres dans l'ordre.

2. L'indice commence à 0

L'une des règles les plus importantes des tableaux est que l'indice commence à 0.

arr[0]   // 第一个元素
arr[1]   // 第二个元素

Ce petit détail est l'un des points où les débutants font le plus souvent des erreurs.

3. Tableau et boucle sont des partenaires naturels

Les opérations courantes sur les tableaux doivent presque toujours être utilisées en combinaison avec des boucles :

for (int i = 0; i < 5; i++)
{
    printf("%d\n", arr[i]);
}

le parcours, la somme, la recherche, le comptage, tout cela repose fondamentalement sur cette combinaison.

4. Tableau bidimensionnel : un tableau de tableaux

Par exemple :

int arr[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

Les tableaux bidimensionnels sont très adaptés pour représenter des données à deux dimensions comme des tables, des matrices ou des bulletins de notes.

IX. Pointeurs : l'étape la plus cruciale pour comprendre le langage C

Beaucoup de gens sont nerveux rien qu'en entendant le mot pointeur.

C'est en effet une partie relativement abstraite du langage C, mais c'est aussi l'endroit qui reflète le mieux les caractéristiques de bas niveau de ce langage.

1. Qu'est-ce qu'un pointeur

Retenez d'abord une phrase :

un pointeur est une variable qui stocke une adresse.

Par exemple :

int a = 10;
int *p = &a;

Ici :

• a est une variable ordinaire
• &a est l'adresse de a
• p est une variable pointeur
• p stocke l'adresse de a

2. Que représente *p

Si p stocke l'adresse de a, alors :

*p

représente l'action de récupérer la valeur située à cet emplacement, via cette adresse.

Par exemple :

printf("%d\n", *p);

Ce qui est affiché est 10.

3. Pointeur simple et pointeur de pointeur

Si une variable pointeur a elle-même une adresse, alors on peut continuer à définir un « pointeur vers un pointeur » :

int a = 10;
int *p = &a;
int **pp = &p;

Bien que cela semble alambiqué, l'essence est simplement que « l'adresse peut aussi continuer à être sauvegardée ».

4. La relation entre pointeurs et tableaux est profonde

Par exemple :

int arr[5] = {10, 20, 30, 40, 50};

Pour accéder au troisième élément :

arr[2]
*(arr + 2)

sont équivalents dans de nombreux scénarios.

Cela montre qu'il existe un lien très étroit entre le nom d'un tableau et l'adresse, et c'est précisément la clé pour comprendre les tableaux, le passage de paramètres aux fonctions et l'arithmétique des pointeurs.

X. Structures, chaînes de caractères et préprocesseur

Une fois les bases précédentes bien consolidées, le langage C passe progressivement de « l'exercice de syntaxe » à « l'expression d'objets réels ».

1. Structures : regrouper plusieurs attributs

Par exemple :

struct Person
{
    char name[10];
    int age;
    float height;
};

Cela signifie qu'une « personne » peut posséder simultanément plusieurs attributs comme le nom, l'âge, la taille.

Pour accéder aux membres d'une structure, l'écriture courante est :

person.age

S'il s'agit d'un pointeur vers une structure, il faut écrire :

p->age

L'importance majeure des structures est qu'elles permettent au programme de ne plus seulement traiter des valeurs individuelles, mais de commencer à traiter « un objet ».

2. Chaînes de caractères

En langage C, une chaîne de caractères n'est pas un type de données indépendant, mais un tableau de caractères.

Par exemple :

char str[] = "hello";

Son essence est une suite de caractères stockés de manière contiguë, avec \0 comme marqueur de fin.

Comprendre cela est très important pour la suite, pour appréhender la longueur des chaînes, l'espace du tableau de caractères et les fonctions de traitement de chaînes.

3. #define : substitution avant compilation

Par exemple :

#define PI 3.14

Ceci n'est pas une variable, mais une substitution de texte effectuée lors de la phase de préprocesseur.

Au stade de l'initiation, il suffit de savoir ceci :

son rôle principal n'est pas de « stocker des données », mais de « remplacer le contenu du code avant la compilation ».

XI. Fichiers : faire interagir le programme avec des données externes

Arrivé à ce stade, le programme n'interagit plus seulement avec le clavier et l'écran.

Il peut aussi lire et écrire des fichiers.

1. Point d'entrée de base pour les opérations sur fichiers

En langage C, les fichiers sont généralement manipulés via un pointeur de fichier.

Par exemple :

FILE *fp = fopen("output.txt", "w");

Ceci signifie ouvrir un fichier en mode écriture.

2. Modes d'ouverture courants

Les modes courants sont :

• "r" : lecture seule
• "w" : écriture seule
• "a" : ajout
• "rb" / "wb" : lecture/écriture en mode binaire
• Avec + : combinaison lecture et écriture

Le mode d'ouverture détermine ce que le programme peut faire avec le fichier.

3. Fonctions courantes de lecture/écriture de fichiers

Par exemple :

• fgetc / fputc
• fgets / fputs

Du point de vue de la compréhension, les opérations sur fichiers sont cohérentes avec les entrées/sorties précédentes :

simplement, l'objet des entrées/sorties passe du clavier et de l'écran aux fichiers sur le disque.

XII. Un schéma complet

Le contenu ci-dessus suit un chemin qui se déploie couche par couche :

• Commencer par les variables, apprendre à stocker des données
• Utiliser les entrées/sorties pour établir une interaction avec le programme
• Utiliser les opérateurs pour traiter les données
• Utiliser les branchements et les boucles pour contrôler le flux
• Utiliser les fonctions pour décomposer les tâches
• Utiliser les tableaux pour traiter un ensemble de données
• Utiliser les pointeurs pour comprendre les adresses et la mémoire
• Puis s'étendre à des scénarios d'application plus réels comme les structures, les chaînes de caractères et les fichiers

Si l'on compare les bases du langage C à la construction d'une maison, alors les variables, les entrées/sorties, les branchements, les boucles, les fonctions, les tableaux et les pointeurs sont les structures construites couche après couche.

Pris isolément, chaque point de connaissance n'est pas particulièrement complexe. Mais c'est seulement en les reliant et en les maîtrisant parfaitement que vous passerez réellement de « savoir écrire quelques exemples » à « commencer à comprendre la programmation ».

C'est aussi pourquoi beaucoup de gens trouvent le langage C difficile, mais une fois qu'ils ont vraiment approfondi, ils le trouvent particulièrement fondamental.

Parce qu'il ne vous apprend pas « comment assembler du code », mais il vous apprend :

comment un programme informatique fonctionne réellement.