Cette page nécessite un navigateur récent (avec support SharedArrayBuffer). Veuillez mettre à jour Chrome, Edge, Firefox ou Safari vers la dernière version.
Chaque programme C commence à main. #include <stdio.h> inclut un en-tête pour pouvoir utiliser printf pour l'impression. Une fonction est un bloc nommé que vous pouvez appeler ; \n crée une nouvelle ligne. main retourne 0 pour signifier « succès ».
#include <stdio.h>
void greet(void) {
printf("Hello, world!\n");
}
int main(void) {
greet();
printf("I am learning C.\n");
return 0;
}
Chaque programme C s'exécute à partir de main après avoir inclus les headers
1.2
Variables, types & arithmétique
C nécessite un type pour chaque variable : int (entier), double (virgule flottante), char (un seul caractère). printf utilise un format spécificateur — %d, %f, %c — pour chaque valeur. / entre deux entiers est une division entière ; % est le reste.
#include <stdio.h>
int main(void) {
int n = 17;
double pi = 3.14;
char grade = 'A';
printf("%d %.2f %c\n", n, pi, grade); // 17 3.14 A
printf("%d %d\n", 7 / 2, 7 % 2); // 3 1
return 0;
}
La chaîne de format contrôle à la fois l'impression et la lecture :
Spécificateur
Type
Exemple de sortie
%d
int
17
%f
double (%.2f = 2 décimales)
3.14
%c
char
A
%s
une chaîne de caractères
Mei
%zu
une taille (de sizeof / strlen)
3
%x
unsigned int, imprimé en base 16
ff
scanf("%d", &n) lit un int via son adresse (notez le &). Les formats d'entrée et de sortie ne sont pas identiques : printf("%f", x) affiche un double, mais scanf("%lf", &x) lit un double ; l'entrée %f nécessite un float *. Vérifiez le nombre retourné d'éléments assignés avec succès. Son sibling sscanf extrait des valeurs d'une chaîne :
#include <stdio.h>
int main(void) {
char line[] = "Mei 88";
char name[20];
int score;
if (sscanf(line, "%19s %d", name, &score) != 2) return 1;
printf("%s scored %d\n", name, score); // Mei scored 88
return 0;
}
1.3
Commentaires & style
Un commentaire est une note pour les humains ; le compilateur l'ignore. Utilisez // pour une seule ligne et /* ... */ pour un bloc. Une bonne indentation et des noms clairs rendent le code facile à lire.
#include <stdio.h>
int main(void) {
// a single-line comment
/* a block
comment */
int total = 3 + 4; // clear names help
printf("%d\n", total); // 7
return 0;
}
Erreurs courantes
Les déclarations et expressions se terminent par ; ; un bloc composé { ... } ne nécessite pas de point-virgule supplémentaire. main devrait retourner int (return 0;).
printf nécessite une chaîne de format : %d pour int, %f pour double, et \n pour une nouvelle ligne.
Un format incorrect comme %d pour un double provoque un comportement indéfini ; il n'est pas garanti qu'il n'imprime que des caractères aléatoires. Faites correspondre le type de l'argument.
Un if exécute un bloc quand une condition 条件 est vraie. C n'a pas de véritable type booléen 布尔值 par défaut : 0 est faux et toute valeur non nulle est vraie. Enchaînez les choix avec else if et else. Comparez avec ==, !=, <, >, <=, >=.
#include <stdio.h>
int main(void) {
int score = 72;
if (score >= 90) {
printf("A\n");
} else if (score >= 60) {
printf("Pass\n");
} else {
printf("Fail\n");
}
return 0;
}
if choisit la branche vraie ; else la branche fausse
2.2
interrupteur
Un switch sélectionne un case basé sur une valeur entière. Chaque case nécessite un break pour sortir 跳出 — sans cela, C « tombe » dans le case suivant. default s'exécute quand rien ne correspond.
#include <stdio.h>
int main(void) {
int day = 3;
switch (day) {
case 1: printf("Mon\n"); break;
case 2: printf("Tue\n"); break;
case 3: printf("Wed\n"); break;
default: printf("Other\n");
}
return 0;
}
Erreurs courantes
if (x = 5) affecte et est toujours vrai ; utilisez == pour comparer.
Chaque switch case nécessite un break;, sinon il tombe dans le suivant.
0 est faux et toute valeur non nulle est vraie dans une condition.
Une boucle 循环 répète un bloc. Une boucle while s'exécute tant qu'une condition est vraie. Une boucle for regroupe l'initialisation, le test et l'incrémentation 自增 (i++) sur une seule ligne — idéal quand on sait combien de fois répéter.
#include <stdio.h>
int main(void) {
int i = 1;
while (i <= 3) {
printf("%d ", i);
i++;
}
printf("\n"); // 1 2 3
for (int j = 0; j < 5; j++) {
printf("%d ", j);
}
printf("\n"); // 0 1 2 3 4
return 0;
}
while vérifie une condition ; for compte avec un pas
3.2
Accumulation
Un motif courant : initialiser un accumulateur 累加器 à 0, puis l'incrémenter à l'intérieur d'une boucle. La même logique sert à compter des éléments ou trouver un total cumulé.
#include <stdio.h>
int main(void) {
int total = 0;
for (int i = 1; i <= 5; i++) {
total += i; // 1 + 2 + 3 + 4 + 5
}
printf("%d\n", total); // 15
return 0;
}
3.3
Boucles imbriquées & motifs
Une boucle à l'intérieur d'une autre boucle est une boucle imbriquée 嵌套. La boucle intérieure se termine complètement pour chaque étape de la boucle extérieure — parfait pour les grilles et les motifs.
#include <stdio.h>
int main(void) {
for (int row = 0; row < 3; row++) {
for (int col = 0; col < 3; col++) {
printf("*");
}
printf("\n");
}
return 0;
}
Erreurs courantes
for (i = 0; i < n; i++) s'exécute n fois ; un point-virgule juste après for (...) crée une boucle vide.
Une while dont la condition ne devient jamais fausse boucle indéfiniment.
Déclarez le compteur (int i) avant ou dans l'en-tête for.
Une fonction prend des paramètres 参数 (entrées) et retourne une valeur de retour 返回值. Le type de retour se trouve en premier (int, double, …) ; void signifie qu'elle ne retourne rien.
#include <stdio.h>
int square(int x) { // x is a parameter
return x * x; // hand back a value
}
int main(void) {
int r = square(5);
printf("%d\n", r); // 25
return 0;
}
Paramètres in; valeur de retour out
4.2
Prototypes et portée
C lit de haut en bas, donc une fonction doit être connue avant d'être appelée. Un prototype 函数原型 — la ligne d'en-tête plus ; — la déclare tôt pour que vous puissiez garder main en premier. La portée 作用域 d'une variable est le bloc dans lequel elle existe : elle est locale 局部 et disparaît lorsque le bloc se termine.
#include <stdio.h>
int add(int a, int b); // prototype: declared before use
int main(void) {
printf("%d\n", add(3, 4)); // 7
return 0;
}
int add(int a, int b) { // definition comes later
int sum = a + b; // sum is local to add
return sum;
}
Erreurs courantes
Une fonction utilisée avant d'être définie nécessite un prototype au-dessus de main.
Les arguments sont passés PAR VALEUR — les modifications à l'intérieur d'une fonction n'affectent pas l'appelant sauf si vous passez un pointeur.
Une variable déclarée à l'intérieur d'une fonction lui est locale.
Un tableau contient plusieurs valeurs d'un même type. Indexez à partir de 0. C ne stocke pas la longueur d'un tableau, aussi une astuce courante calcule le nombre d'éléments : sizeof(a) / sizeof(a[0]).
#include <stdio.h>
int main(void) {
int scores[3] = {88, 71, 95};
printf("%d\n", scores[0]); // 88
scores[1] = 100;
printf("%d\n", scores[1]); // 100
int n = sizeof(scores) / sizeof(scores[0]);
printf("%d\n", n); // 3
return 0;
}
Les cases du tableau sont indexées à partir de 0
5.2
Algorithmes sur tableaux
Parcourez un tableau avec une boucle for pour trouver un max, un total ou un compteur. Bouclez toujours de 0 jusqu'à n - 1.
#include <stdio.h>
int main(void) {
int a[] = {3, 9, 2, 7};
int n = sizeof(a) / sizeof(a[0]);
int max = a[0], total = 0;
for (int i = 0; i < n; i++) {
if (a[i] > max) max = a[i];
total += a[i];
}
printf("%d %d\n", max, total); // 9 21
return 0;
}
5.3
Tableaux 2-D
Un tableau 2-D est une grille de lignes et colonnes : grid[row][col]. Utilisez deux boucles imbriquées pour visiter chaque cellule.
#include <stdio.h>
int main(void) {
int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
printf("%d\n", grid[1][2]); // 6
for (int r = 0; r < 2; r++) {
for (int c = 0; c < 3; c++) {
printf("%d ", grid[r][c]);
}
}
printf("\n"); // 1 2 3 4 5 6
return 0;
}
Erreurs courantes
C ne vérifie PAS les limites du tableau : écrire a[n] dans un tableau de taille n est un comportement non défini.
Les indices valides vont de 0 à n - 1.
Dans la plupart des expressions, un tableau se convertit en pointeur vers son premier élément, mais le tableau lui-même n'est pas un pointeur. sizeof(a) donne la taille totale en octets pour un tableau réel ; un paramètre de tableau est ajusté en pointeur, donc cette fonction a besoin d'une longueur fournie séparément.
Un pointeur 指针 stocke l'adresse 地址 d'une variable. &x donne l'adresse de x ; *p déréférence 解引用 le pointeur — il lit ou écrit la valeur stockée là. Passer un pointeur permet à une fonction de modifier la variable de l'appelant (passage par pointeur).
Un pointeur stocke une adresse ; sa déréference suit la flèche vers la valeur
#include <stdio.h>
void addOne(int *p) { // p holds an address
*p = *p + 1; // change the value at that address
}
int main(void) {
int x = 10;
int *ptr = &x; // & takes the address of x
printf("%d\n", *ptr); // * reads the value: 10
addOne(&x);
printf("%d\n", x); // 11 — changed through the pointer
return 0;
}
L'usage classique est une fonction d'échange. Passer des valeurs ne fait que les copier — l'échange est perdu. Passer des pointeurs permet à la fonction d'accéder aux variables de l'appelant :
#include <stdio.h>
void swap_values(int a, int b) { // copies: the caller sees nothing
int t = a; a = b; b = t;
}
void swap_pointers(int *a, int *b) { // addresses: the swap is real
int t = *a; *a = *b; *b = t;
}
int main(void) {
int x = 1, y = 2;
swap_values(x, y);
printf("%d %d\n", x, y); // 1 2 (unchanged!)
swap_pointers(&x, &y);
printf("%d %d\n", x, y); // 2 1 (swapped)
return 0;
}
Le nom d'un tableau agit comme un pointeur vers son premier élément, et l'arithmétique de pointeur 指针运算 avance par éléments entiers :
#include <stdio.h>
int main(void) {
int a[] = {10, 20, 30};
int *p = a; // same as &a[0]
printf("%d\n", *p); // 10
printf("%d\n", *(p + 2)); // 30 — same as a[2]
return 0;
}
NULL est un pointeur qui ne pointe sur rien — vérifiez-le avant de le déréférencer.
Erreurs courantes
&x est l'adresse de x ; *p est la valeur stockée à p.
N'utilisez jamais *p sur un pointeur non initialisé ou NULL — cela provoque un crash ou une corruption de mémoire.
Pour modifier la variable de l'appelant, passez son adresse et écrivez via le pointeur.
Une chaîne C 字符串 est un tableau de char. Chaque chaîne se termine par un terminateur null caché 空终止符 '\0', qui marque où elle s'arrête. strlen (depuis <string.h>) compte les caractères jusqu'à ce '\0'. Imprimez une chaîne entière avec %s et un caractère 字符 avec %c.
#include <stdio.h>
#include <string.h>
int main(void) {
char name[] = "Mei"; // 'M', 'e', 'i', '\0'
printf("%s\n", name); // Mei
printf("%zu\n", strlen(name)); // 3 (stops at '\0')
printf("%c\n", name[0]); // M
return 0;
}
Une chaîne C est un tableau de char se terminant par un terminateur nul caché
Vous pouvez parcourir une chaîne en bouclant jusqu'à ce que vous atteigniez '\0'.
#include <stdio.h>
int main(void) {
char word[] = "banana";
int count = 0;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == 'a') count++;
}
printf("%d\n", count); // 3
return 0;
}
7.2
La bibliothèque string.h
#include <string.h> vous fournit les outils courants pour les chaînes :
Fonction
Fait
strlen(s)
la longueur, sans compter le terminateur
strcpy(dst, src)
copier — dst doit être assez grand
strcat(dst, src)
ajouter src à la fin de dst
strcmp(a, b)
comparer : 0 si égal, sinon négatif / positif
#include <stdio.h>
#include <string.h>
int main(void) {
char full[40];
strcpy(full, "Mei"); // full is now "Mei"
strcat(full, " Chen"); // append -> "Mei Chen"
printf("%s (%zu)\n", full, strlen(full)); // Mei Chen (8)
printf("%d\n", strcmp("apple", "apple") == 0); // 1 (equal)
return 0;
}
strcmp retourne 0 pour l'égalité, donc le test est strcmp(a, b) == 0 — jamais a == b.
Le tableau de destination doit avoir de la place pour le résultat plus le terminateur.
Erreurs courantes
Une chaîne C a besoin d'un octet supplémentaire pour le terminateur \0 : un mot de 5 lettres nécessite char[6].
Copiez et comparez des chaînes avec strcpy / strcmp, pas = / ==.
Oublier le \0 fait que printf("%s", ...) dépasse la fin du texte.
Une struct 结构体 regroupe des valeurs liées en un seul type. Chaque valeur est un membre 成员. typedef donne à la struct un nom court afin que vous puissiez écrire Dog au lieu de struct Dog. Utilisez . sur une valeur de struct, mais -> sur un pointeur vers une struct.
#include <stdio.h>
typedef struct {
char name[20];
int age;
} Dog;
int main(void) {
Dog d = {"Rex", 3};
printf("%s is %d\n", d.name, d.age); // Rex is 3 (. on a value)
Dog *p = &d;
p->age = 4; // -> on a pointer
printf("%s is %d\n", d.name, d.age); // Rex is 4
return 0;
}
Erreurs courantes
Utilisez . sur une valeur de struct et -> sur un pointeur de struct.
typedef vous permet de supprimer le mot struct lors de la déclaration ; sans cela, vous écrivez struct Point p;.
Assigner une struct à une autre copie tous ses champs.
. pour les valeurs de struct ; -> pour les pointeurs vers des structs
malloc alloue de la mémoire sur le tas au moment de l'exécution et retourne un pointeur vers celle-ci. realloc redimensionne ce bloc ; free la restitue. Chaque malloc nécessite un free correspondant, sinon vous avez une fuite de mémoire. Ceux-ci vivent dans <stdlib.h>.
Les variables locales vivent sur la pile ; la mémoire malloc vit sur le tas jusqu'à ce que vous la libériez
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n = 3;
int *a = malloc(n * sizeof(int)); // room for 3 ints
if (a == NULL) return EXIT_FAILURE;
for (int i = 0; i < n; i++) a[i] = i * 10;
int *grown = realloc(a, 4 * sizeof *a); // positive size
if (grown == NULL) {
free(a);
return EXIT_FAILURE;
}
a = grown;
a[3] = 30;
for (int i = 0; i < 4; i++) printf("%d ", a[i]);
printf("\n"); // 0 10 20 30
free(a); // hand the memory back
return 0;
}
calloc(n, size) alloue un tableau comme malloc ET le remplit de zéros.
Erreurs courantes
Chaque malloc nécessite un free correspondant ; oublier de libérer entraîne une fuite de mémoire.
Utiliser de la mémoire après free (un « use-after-free ») est un bug grave.
Vérifiez que malloc n'a pas renvoyé NULL avant d'utiliser la mémoire.
Pour des tailles positives, un échec realloc retourne NULL et laisse l'allocation précédente intacte : vérifiez un résultat temporaire avant de remplacer votre unique pointeur. Le succès préserve le plus petit des comptes d'octets anciens/nouveaux ; les cellules ajoutées sont non initialisées. Cet exemple évite les demandes de taille zéro et le dépassement de taille. Les variables locales ordinaires non statiques ont une durée de vie automatique et sont généralement implémentées sur une pile ; C ne requiert pas cette disposition.
Une liste chainée 链表 est une chaîne de nœuds 节点. Chaque nœud contient une valeur et un pointeur vers le nœud next ; le dernier pointe vers NULL. Contrairement à un tableau, elle croît d'un nœud à la fois avec malloc. Libérez toujours free chaque nœud une fois terminé.
Une liste chainée : chaque nœud contient une valeur et un pointeur vers le suivant, se terminant à NULL
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int value;
struct Node *next;
} Node;
int main(void) {
Node *head = NULL;
for (int v = 10; v <= 30; v += 10) { // prepend 10, 20, 30
Node *n = malloc(sizeof(Node));
n->value = v;
n->next = head;
head = n;
}
for (Node *p = head; p != NULL; p = p->next) {
printf("%d ", p->value); // 30 20 10
}
printf("\n");
while (head != NULL) { // free the whole list
Node *t = head;
head = head->next;
free(t);
}
return 0;
}
10.2
Piles et files
Une pile 栈 est LIFO 后进先出 (last in, first out) : push et pop à la même extrémité. Une file 队列 est FIFO 先进先出 (first in, first out) : ajout à l'arrière, retrait à l'avant. Les deux sont faciles à implémenter sur un tableau avec des variables d'index.
#include <stdio.h>
int main(void) {
int stack[10];
int top = 0; // next free slot
stack[top++] = 1; // push
stack[top++] = 2;
stack[top++] = 3;
while (top > 0) {
printf("%d ", stack[--top]); // pop: 3 2 1
}
printf("\n");
return 0;
}
#include <stdio.h>
int main(void) {
int queue[10];
int front = 0, back = 0;
queue[back++] = 1; // enqueue
queue[back++] = 2;
queue[back++] = 3;
while (front < back) {
printf("%d ", queue[front++]); // dequeue: 1 2 3
}
printf("\n");
return 0;
}
Erreurs courantes
Dans une liste chainée, ne perdez jamais le pointeur head, sinon toute la liste devient inaccessible.
Libérez chaque nœud une fois terminé, en parcourant la liste avant de la détacher.
Vérifiez une liste vide (une tête NULL) avant de faire un pop.
La recherche linéaire 线性查找 vérifie chaque élément à tour de rôle — elle fonctionne sur tout tableau. La recherche binaire 二分查找 est beaucoup plus rapide mais nécessite un tableau trié 已排序 : elle vérifie le milieu et élimine la moitié à chaque étape. Les deux renvoient l'indice, ou -1 s'il est absent.
#include <stdio.h>
int linear(int a[], int n, int target) {
for (int i = 0; i < n; i++)
if (a[i] == target) return i;
return -1;
}
int binary(int a[], int n, int target) {
int lo = 0, hi = n - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] == target) return mid;
else if (a[mid] < target) lo = mid + 1;
else hi = mid - 1;
}
return -1;
}
int main(void) {
int a[] = {2, 5, 8, 12, 16, 23};
int n = sizeof(a) / sizeof(a[0]);
printf("%d %d %d\n", linear(a, n, 12), binary(a, n, 12), binary(a, n, 9));
return 0; // 3 3 -1
}
La recherche linéaire scanne tout ; la recherche binaire divise par deux un intervalle trié
11.2
Tri
Le tri à bulles 冒泡排序 compare répétitivement les voisins et échange 交换 toute paire qui n'est pas dans l'ordre. Après chaque passage, la plus grande valeur « remonte » à la fin.
#include <stdio.h>
int main(void) {
int a[] = {5, 2, 9, 1, 7};
int n = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (a[j] > a[j + 1]) {
int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
}
}
}
for (int i = 0; i < n; i++) printf("%d ", a[i]);
printf("\n"); // 1 2 5 7 9
return 0;
}
11.3
Récursivité
La récursion 递归 est une fonction qui s'appelle elle-même. Elle a besoin d'un cas de base 基准情形 pour s'arrêter, et d'un appel récursif qui s'en rapproche. Sans cas de base, elle ne se termine jamais.
#include <stdio.h>
int factorial(int n) {
if (n <= 1) return 1; // base case
return n * factorial(n - 1); // recursive call
}
int main(void) {
printf("%d\n", factorial(5)); // 120
return 0;
}
Erreurs courantes
La recherche binaire nécessite un tableau trié ; la récursion nécessite un cas de base.
Chaque appel récursif doit se rapprocher du cas de base, sinon la pile déborde.
Les tris par bulles et par insertion sont en O(n²) — bien à apprendre, lents à grande échelle.
fopen retourne un pointeur de fichier ; la chaîne de mode indique l'action — "w" écriture, "r" lecture, "a" ajout. Écrivez avec fprintf, lisez avec fscanf, et fermez toujours le flux fclose une fois terminé.
#include <stdio.h>
int main(void) {
FILE *out = fopen("scores.txt", "w"); // open for writing
if (out == NULL) {
perror("scores.txt");
return 1;
}
fprintf(out, "Alice 80\nBob 95\n");
fclose(out);
FILE *in = fopen("scores.txt", "r"); // open for reading
if (in == NULL) {
perror("scores.txt");
return 1;
}
char name[20];
int score;
while (fscanf(in, "%19s %d", name, &score) == 2) { // %19s leaves room for '\0'
printf("%s -> %d\n", name, score);
}
fclose(in);
return 0;
}
fopen → lecture/écriture → fclose
12.2
Gestion d'erreurs avec codes de retour
Le langage C ne possède pas d'exceptions intégrées. Une fonction peut signaler son résultat via un code de retour ; vérifiez les règles de cette fonction avant d'utiliser le résultat. L'exemple ci-dessous utilise 0 pour la réussite et -1 pour l'échec. La fonction fopen retourne à la place un pointeur de flux, ou NULL en cas d'échec.
#include <stdio.h>
// returns 0 on success, -1 if the divisor is 0
int safe_divide(int a, int b, int *result) {
if (b == 0) return -1; // error code
*result = a / b;
return 0; // success
}
int main(void) {
int r;
if (safe_divide(10, 2, &r) == 0)
printf("10 / 2 = %d\n", r); // 10 / 2 = 5
if (safe_divide(10, 0, &r) != 0)
printf("cannot divide by zero\n"); // error reported
return 0;
}
Erreurs courantes
Vérifiez que fopen n'a pas retourné NULL avant de lire ou d'écrire.
Fermez toujours fclose un fichier une fois terminé.
Renvoyez un code non nul depuis main pour signaler une erreur à l'appelant.
Un bit 位 est un 0 ou 1 unique ; les nombres sont stockés en binaire 二进制. Les opérateurs bit à bit 按位 agissent directement sur les bits : & AND, | OR, ^ XOR, << décalage vers la gauche (×2 à chaque étape), >> décalage vers la droite (÷2).
#include <stdio.h>
int main(void) {
int a = 12; // 1100
int b = 10; // 1010
printf("%d\n", a & b); // 8 AND -> 1000
printf("%d\n", a | b); // 14 OR -> 1110
printf("%d\n", a ^ b); // 6 XOR -> 0110
printf("%d\n", a << 1); // 24 left shift
printf("%d\n", a >> 1); // 6 right shift
return 0;
}
L'hexadécimal 十六进制 (base 16) écrit le binaire de manière compacte : un chiffre hexadécimal correspond exactement à quatre bits. Écrivez les littéraux hexadécimaux avec 0x ; affichez avec %x :
#include <stdio.h>
int main(void) {
printf("%d\n", 0xFF); // 255 (0x marks a hex literal)
printf("%x\n", 255); // ff
printf("%x\n", 12); // c
return 0;
}
Les opérateurs bitwise travaillent sur les bits des entiers
13.2
Codage par longueur de run
La compression par codage de longueur d'exécution (RLE) est une méthode 压缩 simple : remplacez chaque série 游程 de caractères répétés par un compteur et le caractère. C'est sans perte 无损 — l'original est entièrement récupérable.
#include <stdio.h>
#include <string.h>
int main(void) {
char *s = "aaabbc";
int n = strlen(s);
for (int i = 0; i < n; ) {
char c = s[i];
int run = 0;
while (i < n && s[i] == c) { run++; i++; }
printf("%d%c", run, c); // 3a2b1c
}
printf("\n");
return 0;
}
Erreurs courantes
& est un ET bit à bit et && est un ET logique — ne les confondez pas.
Un décalage à gauche << 1 double une valeur ; un décalage à droite >> 1 la divise par deux.
Le bit n a la valeur 1 << n (C n'a pas d'opérateur ** de puissance) ; vérifiez un bit avec (x >> n) & 1.
Le préprocesseur 预处理器 s'exécute avant la compilation. #define crée une macro 宏 — du texte brut remplacé partout. const crée une constante 常量 qui ne peut pas changer. static dans une fonction conserve la valeur d'une variable entre les appels. Une énumération 枚举 enum nomme un ensemble d'entiers commençant à 0.
#include <stdio.h>
#define MAX 100 // macro: text replaced before compiling
enum Color { RED, GREEN, BLUE }; // named integers 0, 1, 2
int next_id(void) {
static int count = 0; // keeps its value between calls
count++;
return count;
}
int main(void) {
const double PI = 3.14; // cannot be changed
printf("%d %.2f\n", MAX, PI); // 100 3.14
printf("%d %d %d\n", RED, GREEN, BLUE); // 0 1 2
int a = next_id();
int b = next_id();
printf("%d %d\n", a, b); // 1 2
return 0;
}
Les programmes plus grands sont répartis sur plusieurs fichiers : les déclarations vont dans un fichier d'en-tête 头文件 (mine.h), inclus avec #include "mine.h" — les guillemets signifient votre propre fichier, < > signifie la bibliothèque standard. Un garde d'inclusion (#ifndef MINE_H / #define MINE_H / #endif) empêche qu'un en-tête soit inclus deux fois.
Erreurs courantes
#define effectue un remplacement de texte brut sans vérification de type ; enroulez les corps et arguments des macro dans des parenthèses.
Une valeur const ne peut pas être modifiée après qu'elle a été définie.
Une variable locale static conserve sa valeur entre les appels à la fonction.
#define, const, enum et static maintiennent le code clair