Langage C

#include <stdio.h>

int main()
{
    printf("Bonjour");
    return 0;
}

int   adresseIP;
int   nombrePaquets;
float debit;

int     float   char    void    const
if      else    switch  case    default
for     while   do      break   continue
return  struct  sizeof  goto

// Cette variable contient le nombre de paquets
int nombrePaquets;

/*
   Calcul du débit réseau
   à partir du nombre de paquets
*/

int nombrePC;          // un entier
int a, b, c;           // trois entiers d'un coup

int   a = 80;
float b = 100.5;
char  c = 'O';

const float PI = 3.14159;
const int   PORT_HTTP = 80;

PI = 3;     // ERREUR de compilation : PI est constante

condition ? expression_si_vrai : expression_si_faux

int a = 10;
int b = 20;
int max = (a > b) ? a : b;     // a > b est faux  →  max = b = 20

printf("bonjour !");

bonjour !

int age = 20;
printf("%d", age);        // 20

int   age    = 20;
float taille = 1.75;
char  lettre = 'a';

printf("age : %d\n", age);
printf("taille : %f\n", taille);
printf("taille : %.2f\n", taille);
printf("lettre : %c\n", lettre);
printf("age : %d ans, moyenne : %.2f/20\n", age, 15.5);

age : 20
taille : 1.750000
taille : 1.75
lettre : a
age : 20 ans, moyenne : 15.50/20

scanf("code_format", &variable);

int   age;
float note;

printf("Entrez votre age : ");
scanf("%d", &age);

printf("Entrez votre note : ");
scanf("%f", &note);

printf("\nVous avez %d ans et votre note est %.2f/20\n", age, note);

Entrez votre age : 20
Entrez votre note : 15.5

Vous avez 20 ans et votre note est 15.50/20

int age = 20;

if (age >= 18) {
    printf("Majeur\n");
}

int age;

printf("entrez votre age : ");
scanf("%d", &age);

if (age >= 18) {
    printf("majeur\n");
} else {
    printf("mineur\n");
}

switch (expression) {
    case valeur1:
        // instructions
        break;
    case valeur2:
        // instructions
        break;
    default:
        // si aucune valeur ne correspond
}

#include <stdio.h>

int main(void)
{
    int choix;

    printf("1 - ajouter\n");
    printf("2 - modifier\n");
    printf("3 - supprimer\n");
    printf("votre choix : ");
    scanf("%d", &choix);

    switch (choix) {
        case 1:
            printf("Ajouter\n");
            break;
        case 2:
            printf("Modifier\n");
            break;
        case 3:
            printf("Supprimer\n");
            break;
        default:
            printf("Choix invalide\n");
    }
    return 0;
}

char reponse;

printf("Voulez-vous continuer ? ");
scanf(" %c", &reponse);

switch (reponse) {
    case 'o':
    case 'O':
        printf("Oui\n");
        break;
    case 'n':
    case 'N':
        printf("Non\n");
        break;
    default:
        printf("Reponse incorrecte\n");
}

#include <stdio.h>

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

1
2
3
4
5

#include <stdio.h>

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

for (initialisation; condition; modification) {
    instructions;
}

#include <stdio.h>

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

#include <stdio.h>

int main()
{
    int i;
    for (i = 1; i <= 10; i++) {
        if (i == 5)
            break;
        printf("%d\n", i);
    }
    return 0;
}

1
2
3
4

#include <stdio.h>

int main()
{
    int i;
    for (i = 1; i <= 5; i++) {
        if (i == 3)
            continue;
        printf("%d\n", i);
    }
    return 0;
}

1
2
4
5

#include <stdio.h>

int main()
{
    printf("debut du programme\n");
    goto fin;
    printf("cette instruction ne sera pas executee\n");
fin:
    printf("fin du programme\n");
    return 0;
}

debut du programme
fin du programme

carre = nombre * nombre;

#include <stdio.h>

int carre(int nombre)
{
    return nombre * nombre;
}

int main(void)
{
    int a = carre(5);
    int b = carre(10);
    int c = carre(20);
    printf("%d %d %d\n", a, b, c);
    return 0;
}

25 100 400

#include <stdio.h>

void afficherBonjour(void)
{
    printf("Bonjour !\n");
}

void afficherCarre(int n)
{
    printf("Le carré de %d est %d\n", n, n * n);
}

int main(void)
{
    afficherBonjour();
    afficherCarre(5);
    return 0;
}

Bonjour !
Le carré de 5 est 25

int saisirNombre(void)
{
    int n;

    printf("Entrez un nombre : ");
    scanf("%d", &n);
    return n;
}

int nombre;
nombre = saisirNombre();

nom_fonction(arguments);              /* sans retour : on l'exécute */

variable = nom_fonction(arguments);   /* avec retour : on range le résultat */

#include <stdio.h>

int additionner(int a, int b);        /* le PROTOTYPE, avec un point-virgule */

int main(void)
{
    int resultat;
    resultat = additionner(5, 3);
    printf("résultat = %d\n", resultat);
    return 0;
}

int additionner(int a, int b)         /* la DÉFINITION, sans point-virgule */
{
    return a + b;
}

résultat = 8

void calculer(void)
{
    int resultat = 0;      /* locale à calculer() */
    resultat = 10 + 20;
    printf("%d\n", resultat);
}

#include <stdio.h>

int val = 0;               /* globale : visible partout */

int carre(void)
{
    return val * val;
}

int main(void)
{
    val = 2;
    printf("le carré de 2 est : %d\n", carre());
    return 0;
}

le carré de 2 est : 4

#include <stdio.h>

int carre(int val)
{
    return val * val;
}

int main(void)
{
    int resultat;
    resultat = carre(2);
    printf("le carré de 2 est : %d\n", resultat);
    return 0;
}

le carré de 2 est : 4

float note1;
float note2;
float note3;
float note4;
float note5;

float notes[5];

#include <stdio.h>

int main(void)
{
    int nombres[5] = {10, 20, 30, 40, 50};

    nombres[1] = 50;          /* la deuxième case passe de 20 à 50 */

    printf("nombres[1] = %d\n", nombres[1]);
    return 0;
}

nombres[1] = 50

#include <stdio.h>

int main(void)
{
    int nombres[5] = {10, 20, 30, 40, 50};
    int somme = 0;
    int i;

    for (i = 0; i < 5; i++)
    {
        somme = somme + nombres[i];
    }

    printf("somme = %d\n", somme);
    return 0;
}

somme = 150

#include <stdio.h>

void combien(int t[])
{
    printf("dans la fonction : sizeof(t) = %zu\n", sizeof(t));
}

int main(void)
{
    int mesures[10];

    printf("dans main       : sizeof(mesures) = %zu\n", sizeof(mesures));
    combien(mesures);
    return 0;
}

dans main       : sizeof(mesures) = 40
dans la fonction : sizeof(t) = 8

int trafic[3][4];      /* 3 lignes, 4 colonnes → 12 cases */
float temperatures[5][4];
int grille[2][2] = { {1, 2}, {3, 4} };

trafic[0][0] = 120;     /* premiere ligne, premiere colonne */
trafic[2][3] = 30;      /* DERNIERE ligne, DERNIERE colonne d'un [3][4] */
printf("%d", trafic[1][2]);

#include <stdio.h>

int main(void)
{
    /* 3 lignes, 4 colonnes : le trafic de trois commutateurs sur quatre ports */
    int trafic[3][4] = {
        { 120,  80, 200,  45 },
        {  90, 150,  60, 110 },
        { 200, 170,  95,  30 }
    };
    int i, j;

    for (i = 0; i < 3; i++) {
        for (j = 0; j < 4; j++)
            printf("%6d", trafic[i][j]);
        printf("\n");
    }

    printf("\ntrafic[1][2] vaut %d\n", trafic[1][2]);
    return 0;
}

   120    80   200    45
    90   150    60   110
   200   170    95    30

trafic[1][2] vaut 60

for (i = 0; i < LIGNES; i++) {       /* la boucle du dehors : les lignes */
    for (j = 0; j < COLONNES; j++) { /* la boucle du dedans : les colonnes */
        /* ici, on travaille sur tableau[i][j] */
    }
}

#include <stdio.h>

#define LIGNES   3
#define COLONNES 4

int main(void)
{
    int trafic[LIGNES][COLONNES] = {
        { 120,  80, 200,  45 },
        {  90, 150,  60, 110 },
        { 200, 170,  95,  30 }
    };
    int i, j;

    for (i = 0; i < LIGNES; i++) {
        int somme = 0;
        for (j = 0; j < COLONNES; j++)
            somme += trafic[i][j];
        printf("commutateur %d : %d\n", i + 1, somme);
    }

    for (j = 0; j < COLONNES; j++) {
        int somme = 0;
        for (i = 0; i < LIGNES; i++)
            somme += trafic[i][j];
        printf("port %d : %d\n", j + 1, somme);
    }
    return 0;
}

commutateur 1 : 445
commutateur 2 : 410
commutateur 3 : 495
port 1 : 410
port 2 : 400
port 3 : 355
port 4 : 185

for (i = 0; i < LIGNES; i++)
    for (j = 0; j < COLONNES; j++) {
        printf("Ligne %d, colonne %d : ", i + 1, j + 1);
        scanf("%d", &tableau[i][j]);
    }

int totalLigne(int t[][5], int ligne);   /* la 2e taille est OBLIGATOIRE */
int totalLigne(int t[4][5], int ligne);  /* ou les deux, au choix */

printf("adresse de age : %p\n", (void *)&age);

int  age = 20;    /* age contient  20                     */
int *p;           /* p contiendra l'adresse d'un int       */
p = &age;         /* desormais : p pointe vers age         */

type *nom;

int    *p;      /* p pointe vers un int    */
float  *q;      /* q pointe vers un float  */
char   *r;      /* r pointe vers un char   */

int *p = NULL;     /* « pour l'instant, p ne pointe vers rien »  */

if (p != NULL)     /* on peut donc tester avant d'y toucher     */
    printf("%d", *p);

#include <stdio.h>

int main(void)
{
    int age = 20;
    int *p;

    p = &age;

    printf("p contient l'adresse de age : %s\n", (p == &age) ? "oui" : "non");
    printf("age vaut %d, et *p vaut %d\n", age, *p);
    printf("un int occupe %zu octets\n", sizeof(int));
    return 0;
}

p contient l'adresse de age : oui
age vaut 20, et *p vaut 20
un int occupe 4 octets

#include <stdio.h>

int main(void)
{
    int age = 20;
    int *p = &age;

    printf("avant  : age = %d\n", age);
    *p = 30;                      /* on ecrit DANS la case pointee par p */
    printf("apres  : age = %d\n", age);
    return 0;
}

avant  : age = 20
apres  : age = 30

void doubler(int *n)      /* n recoit une ADRESSE  */
{
    *n = *n * 2;          /* on ecrit dans l'original */
}

/* a l'appel : */
int v = 21;
doubler(&v);              /* v vaut maintenant 42     */

int tab[5] = {1, 2, 6, 0, 7};

tab == &tab[0]      /* le nom du tableau EST l'adresse de son premier element */

#include <stdio.h>

int main(void)
{
    int tab[5] = {1, 2, 6, 0, 7};
    int *p = tab;
    int i;

    for (i = 0; i < 5; i++) {
        printf("%d\n", *p);
        p++;
    }
    return 0;
}

1
2
6
0
7

p[i]   ==   *(p + i)        /* strictement la meme chose */

p[0]   ==   *p
tab[2] ==   *(tab + 2)

#include <stdlib.h>          /* malloc, calloc et free vivent ici */

int *p;
p = malloc(5 * sizeof(int));   /* « reserve de quoi loger 5 int »  */

p = malloc(n * sizeof(int));
if (p == NULL) {
    printf("memoire insuffisante\n");
    return 1;
}

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *p;
    int i;

    p = malloc(5 * sizeof(int));
    if (p == NULL) {
        printf("memoire insuffisante\n");
        return 1;
    }

    for (i = 0; i < 5; i++)
        p[i] = (i + 1) * 10;

    for (i = 0; i < 5; i++)
        printf("p[%d] = %d\n", i, p[i]);

    free(p);
    return 0;
}

p[0] = 10
p[1] = 20
p[2] = 30
p[3] = 40
p[4] = 50

int *a = malloc(4 * sizeof(int));   /* 4 cases, contenu indetermine */
int *b = calloc(4, sizeof(int));    /* 4 cases, toutes a ZERO       */

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *a = malloc(4 * sizeof(int));
    int *b = calloc(4, sizeof(int));
    int i;

    if (a == NULL || b == NULL) return 1;

    printf("calloc met tout a zero :\n");
    for (i = 0; i < 4; i++)
        printf("b[%d] = %d\n", i, b[i]);

    free(a);
    free(b);
    return 0;
}

calloc met tout a zero :
b[0] = 0
b[1] = 0
b[2] = 0
b[3] = 0

free(p);        /* la zone redevient disponible pour le programme */

malloc() ou calloc()  ->  reserver
      utiliser          ->  p[0], p[1], ...
        free()          ->  rendre

char  nom[30];      /* trois variables independantes :        */
int   age;          /* rien ne dit qu'elles decrivent          */
float moyenne;      /* le meme etudiant                        */

struct Etudiant {
    char  nom[30];
    int   age;
    float moyenne;
};                    /* ce point-virgule est OBLIGATOIRE */

struct Etudiant e1;              /* une fiche vierge               */
struct Etudiant e1, e2, e3;      /* trois fiches, independantes    */

e1.age     = 20;
e1.moyenne = 15.5;

struct Etudiant e1 = {"Alice", 20, 15.5};        /* dans l'ordre des champs */

struct Etudiant e2 = {                           /* ou en nommant les champs */
    .nom     = "Bilal",
    .age     = 19,
    .moyenne = 12.0
};

#include <stdio.h>
#include <string.h>

struct Etudiant {
    char  nom[30];
    int   age;
    float moyenne;
};

int main(void)
{
    struct Etudiant e1;

    strcpy(e1.nom, "Alice");      /* une chaine ne se copie pas avec = */
    e1.age = 20;
    e1.moyenne = 15.5;

    printf("Nom     : %s\n", e1.nom);
    printf("Age     : %d\n", e1.age);
    printf("Moyenne : %.2f\n", e1.moyenne);
    return 0;
}

Nom     : Alice
Age     : 20
Moyenne : 15.50

struct Etudiant classe[5];        /* cinq fiches, numerotees de 0 a 4 */

classe[0].age  = 20;              /* tableau[indice].champ            */
classe[2].moyenne = 17.25;

#include <stdio.h>

struct Etudiant {
    char  nom[30];
    int   age;
    float moyenne;
};

int main(void)
{
    struct Etudiant classe[3] = {
        { "Alice",  20, 15.5f },
        { "Bilal",  19, 12.0f },
        { "Chloe",  21, 17.25f }
    };
    float somme = 0;
    int i;

    for (i = 0; i < 3; i++) {
        printf("%-8s %3d ans  %5.2f\n", classe[i].nom, classe[i].age, classe[i].moyenne);
        somme += classe[i].moyenne;
    }
    printf("moyenne de la classe : %.2f\n", somme / 3);
    return 0;
}

Alice     20 ans  15.50
Bilal     19 ans  12.00
Chloe     21 ans  17.25
moyenne de la classe : 14.92

#include <stdio.h>

struct Etudiant {
    char  nom[30];
    int   age;
    float moyenne;
};

/* PAR VALEUR : la fonction recoit une copie, l'original ne bouge pas */
void vieillirCopie(struct Etudiant e)      { e.age = e.age + 1; }

/* PAR ADRESSE : la fonction recoit l'adresse, elle ecrit dans l'original */
void vieillir(struct Etudiant *e)          { e->age = e->age + 1; }

void afficher(struct Etudiant e)
{
    printf("%s, %d ans, moyenne %.2f\n", e.nom, e.age, e.moyenne);
}

int main(void)
{
    struct Etudiant e1 = { "Alice", 20, 15.5f };

    vieillirCopie(e1);
    printf("apres vieillirCopie : ");  afficher(e1);

    vieillir(&e1);
    printf("apres vieillir      : ");  afficher(e1);
    return 0;
}

apres vieillirCopie : Alice, 20 ans, moyenne 15.50
apres vieillir      : Alice, 21 ans, moyenne 15.50

struct Etudiant e1;
struct Etudiant *p = &e1;

e1.age   = 20;      /* une structure      -> le point  */
p->age   = 20;      /* un pointeur dessus -> la fleche */

(*p).age = 20;      /* exactement la meme chose, en plus lourd */

/* sans typedef */                   /* avec typedef */
struct Etudiant {                     typedef struct {
    char nom[30];                         char nom[30];
    int  age;                             int  age;
};                                    } Etudiant;

struct Etudiant e1;                   Etudiant e1;
struct Etudiant e2;                   Etudiant e2;

struct Date {
    int jour;
    int mois;
    int annee;
};

struct Etudiant {
    char        nom[30];
    int         age;
    float       moyenne;
    struct Date naissance;      /* un champ qui est lui-meme une structure */
};

e1.naissance.jour  = 15;        /* e1 -> naissance -> jour */
e1.naissance.mois  = 4;
e1.naissance.annee = 2005;

#include <stdio.h>
#include <string.h>

struct Date {
    int jour;
    int mois;
    int annee;
};

typedef struct {
    char        nom[30];
    int         age;
    float       moyenne;
    struct Date naissance;
} Etudiant;                       /* typedef : plus besoin d'ecrire « struct » */

int main(void)
{
    Etudiant e1;

    strcpy(e1.nom, "Alice");
    e1.age = 20;
    e1.moyenne = 15.5;
    e1.naissance.jour  = 15;
    e1.naissance.mois  = 4;
    e1.naissance.annee = 2005;

    printf("%s, ne le %02d/%02d/%d\n", e1.nom,
           e1.naissance.jour, e1.naissance.mois, e1.naissance.annee);
    return 0;
}

Alice, ne le 15/04/2005

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct Etudiant {
    char  nom[30];
    int   age;
    float moyenne;
};

int main(void)
{
    struct Etudiant *p;

    p = malloc(sizeof(struct Etudiant));
    if (p == NULL) {
        printf("Erreur d'allocation memoire\n");
        return 1;
    }

    strcpy(p->nom, "Alice");
    p->age = 20;
    p->moyenne = 15.5;

    printf("Nom     : %s\n", p->nom);
    printf("Age     : %d\n", p->age);
    printf("Moyenne : %.2f\n", p->moyenne);

    free(p);
    return 0;
}

Nom     : Alice
Age     : 20
Moyenne : 15.50

char nom[30];             /* 30 cases, chacune un caractere */
char mot[] = "Salut";     /* le compilateur compte pour vous */

char mot[] = "Salut";

/*  s  |  a  |  l  |  u  |  t  | \0   <- 6 cases pour 5 lettres */

char nom[] = "Alice";
char nom[] = {'A', 'l', 'i', 'c', 'e', '\0'};   /* exactement la meme chose */

char nom[20] = "Alice";   /* A l i c e \0 \0 \0 ... jusqu'a la 20e case */

#include <stdio.h>

int main(void)
{
    char lettre = 'A';          /* apostrophes simples : UN caractere  */
    char mot[] = "Alice";       /* guillemets : une CHAINE             */

    printf("%c\n", lettre);
    printf("%s\n", mot);

    return 0;
}

A
Alice

#include <stdio.h>

int main(void)
{
    char nom[30];

    printf("Entrez votre nom : ");
    scanf("%s", nom);                 /* pas de & : voir l'encart */
    printf("Bonjour %s !\n", nom);

    return 0;
}

#include <stdio.h>

int main(void)
{
    char nom[50];

    printf("Entrez votre nom : ");
    fgets(nom, 50, stdin);            /* stdin : le clavier */
    printf("Bonjour %s", nom);

    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void)
{
    char source[] = "Bonjour";
    char destination[20];
    char prenom[50] = "Alice";
    char nom[] = " Dupont";

    printf("Longueur : %zu\n", strlen(source));

    strcpy(destination, source);
    printf("Copie    : %s\n", destination);

    strcat(prenom, nom);
    printf("Colle    : %s\n", prenom);

    return 0;
}

Longueur : 7
Copie    : Bonjour
Colle    : Alice Dupont

#include <stdio.h>
#include <string.h>

int main(void)
{
    char nom1[] = "Alice";
    char nom2[] = "Sara";

    if (strcmp(nom1, nom2) == 0) {
        printf("Les deux noms sont identiques.\n");
    } else {
        printf("Les deux noms ne sont pas identiques.\n");
    }

    return 0;
}

Les deux noms ne sont pas identiques.

#include <stdio.h>

int main(void)
{
    char mot[] = "Bonjour";
    int i = 0;

    while (mot[i] != '\0') {
        printf("%c\n", mot[i]);
        i++;
    }

    return 0;
}

B
o
n
j
o
u
r