Bienvenue chez Ne0Futur =|{)

La compilation d'un programme en langage C sous Linux

Neo futur — 2005-12-05T16:15:12Z

Compiler, sous Linux, un simple programme (monilitique) en langage C
Un programme monolitique est un programme qui est entièrement contenu dans un seul fichier.

C'est le cas de tous les petits programmmes donnés en exemple dans les bases du langage C, et dans le tutoriel langage C.

Dans ce cas, la compilation est très simple, dans un terminal, positionnez vous dans le répertoire qui contient votre source C et tapez la commande suivante ( en partant du principe que votre fichier s'appele programme.c ) :

cc programme.c -o programme.exe

Si le compilateur trouve des erreurs de syntaxe dans votre programme, il vous le dira. . .

Si il n'y a pas d'erreurs de syntaxe dans votre programme, le repertoire contiendra alors un fichier programme.exe, qu'il vous suffira d'executer en tapant :

./programme.exe

A noter :

L'option '-o' de la commande cc permets de spécifier le nom de l'exécutable qui sera créé.

Cette option n'est pas obligatoire, si elle n'est pas spécifiée, l'exécutable créé sera appelé par défaut 'a.out'

L'extension '.exe' n'est pas non plus obligatoire sous GNU/Linux ; elle est seulement pratique pour voir rapidement dans un repertoire, quels sont les fichiers binaires ( exécutables ).

Ainsi vous auriez aussi bien pu taper :

cc programme.c -o programme ./programme

ou bien :

cc programme.c -o programme.bin ./programme.bin
Compiler, sous Linux, un programme 'multi-fichiers' en langage C :
Un programme 'multi-fichiers' est un programme dont le source est éparpillé entre plusieurs fichiers source C.

Ceci est tres utile, dès que vous commencez a faire de gros programmes, qui vont contenir plusieurs millers de lignes de code.

En effet, si on se retrouve avec 10000 lignes de code ( ce qui fait un programme moyen ) dans un seul fichier source, il est tres difficile de lire et de comprendre le source.

De plus, il est tres utile de regrouper dans un fichier source C, toutes les fonctions qui ont un point commun.

Il est alors d'usage de séparer le code dans plusieurs fichiers.

Par exemple :

Nous disposons des fichiers sources suivants :

programme.h main.c interface.c callbacks.c support.c

A noter :

Le fichier programme.h devra contenir les prototypes de toutes les fonctions qui seront utilisées dans les différents fichiers *.c.

De plus, chaque fichier *.c contiendra, au debut, une ligne :

#include "programme.h"

Ceci est necessaire pour que le compilateur puisse vérifier que l'appel, dans interface.c, d'une fonction qui se trouve dans support.c, est correct.

Pour compiler tous ces sources C, et créer un seul executable, dans un terminal, positionnez vous dans le répertoire qui contient vos sources C et tapez la commande suivante :

cc main.c interface.c callbacks.c support.c -o programme.exe

Si le compilateur trouve des erreurs de syntaxe dans votre programme, il vous le dira, c'est l'un des avantages d'utiliser Linux, le systeme ( ici le compilateur =|- vous parle, et tout est plus facile.

Si il n'y a pas d'erreurs de syntaxe dans votre programme, le repertoire contiendra alors un fichier programme.exe, qu'il vous suffira d'executer en tapant :

./programme.exe

A noter :

Il ne faut pas mettre le fichier programme.h dans la ligne de compilation, car ce fichier est d'ores et déjà inclus dans les fichiers *.c, grace a la ligne :

#include "programme.h"

6- Les instructions de contrôle du langage C

Neo futur — 2005-12-05T15:55:39Z

Les instructions s'appliquent à un bloc de code, ainsi une suite logique de plusieurs lignes seront concernées par l'instruction.

Le bloc de code concerné par l"instruction est celui qui la suit immédiatement et qui se trouve entre accolades.

L'instruction if et l'instruction else

int nombre=0; if ( nombre > 0) { printf ("nombre superieur a zero\n"); } else { printf ("nombre inferieur a 1\n"); }
L'instruction for

int i =0; for ( i=0; i<20 ; i++ ) { printf(" i=%d\n",i); }
L'instruction while

int i =0; while ( i<21) { printf(" i=%d\n",i); i++ }
L'instruction switch

int type=3; switch (type) { case 1: printf("choix 1"); case 2: printf("choix 2"); case 3: printf("choix 3"); case 4: printf("choix 4"); case 5: printf("choix 5"); }
L'instruction do while

int i =0; do { printf(" i=%d\n",i); i++ }while ( i < 21);
L'instruction break

int i =0; do { printf(" i=%d\n",i); if ( b == 7 ) break; }while ( i < 21 );
L'instruction continue

do { if ( b == 4 ) continue; printf(" i=%d\n",i); }while ( );

5- Les entrées / sorties dans le langage C

Neo futur — 2005-12-05T14:45:12Z

Comment saisir et afficher un caractère

Dans un simple fichier texte, que vous editerez avec votre éditeur de texte favori ( sous Linux : vi, kedit, kwrite, gnp, kdevelop ou code commander feront l'affaire ), saisissez ( ou copiez/collez ) le texte suivant :

( getchar.c ) :

Pour compiler et exécuter ce programme :

Sauvegardez le programme sous le nom caractere.c dans votre répertoire personnel.
Saisissez dans un terminal ( dans le même répertoire ), la commande suivante :
cc getchar.c -o getchar.exe

Cette commande signifie :

Compile le fichier caractere.c et crée un executable ( option -o ) qui s'appelera caractere.exe
Pour lancer l'executable caractere.exe, Saisissez dans un terminal ( toujours dans le même répertoire ), la commande suivante :
./getchar.exe

Comment saisir et afficher une chaine de caractère

( chaine.c ) :

#include <stdio.h> void main(void) { // On declare une variable char de taille 128, qui peut contenir // un maximum de 128 caracteres. // En fait c'est ce qu l'on appelle une chaine de caractères // ou encore un tableau de caractères // Par defaut cette variable contiendra la chaine 'chaine initiale' char ch_chaine_de_128_max[128] = "chaine initiale"; // On affiche le caractère par defaut printf("Au début, la chaine contient : %s \n", ch_chaine_de_128_max ); // On demande a l'utilisateur de saisir un une chaine de caractères printf(" Veuillez saisir une chaine de caractères ( 128 caractères maximum ) SVP \n"); // On attends que l'utilisateur ait saisi une chaine de caractères // que l'on rangera dans notre variable ch_chaine_de_128_max scanf("%127s", ch_chaine_de_128_max ); // On affiche la chaine de caractères saisie par l'utilisateur printf("Maintenant, la chaine de caractereactères contient : \n%s\n", ch_chaine_de_128_max ); printf(" AU REVOIR !!!\n"); }

Pour compiler et exécuter ce programme :

Sauvegardez le programme sous le nom chaine.c dans votre répertoire personnel.
Saisissez dans un terminal ( dans le même répertoire ), la commande suivante :
cc chaine.c -o chaine.exe

Cette commande signifie :

Compile le fichier chaine.c et crée un executable ( option -o ) qui s'appelera chaine.exe
Pour lancer l'executable chaine.exe, Saisissez dans un terminal ( toujours dans le même répertoire ), la commande suivante :
./chaine.exe

Comment saisir et afficher un nombre entier

( entier.c ) :

#include <stdio.h> void main(void) { // On declare une variable int, qui peut contenir un nombre entier. // Par defaut cette variable contiendra le nombre entier 1 int i_contient_un_entier = 1; // On affiche l'entier par defaut printf("Au début, l'entier contient : %d \n", i_contient_un_entier ); // On demande a l'utilisateur de saisir un une chaine de caractères printf(" Veuillez saisir un nombre entier ( inferieur a 999999999 SVP \n"); // On attends que l'utilisateur ait saisi un nombre entier // que l'on rangera dans notre variable i_contient_un_entier // Seuls les 9 premiers chiffres de la saisie seront pris en compte ( %9d ) scanf("%9d", &i_contient_un_entier ); // On affiche la chaine de caractères saisie par l'utilisateur printf("Maintenant, le nombre entier est : %d \n", i_contient_un_entier ); printf(" AU REVOIR !!!\n"); }

Pour compiler et exécuter ce programme :

Sauvegardez le programme sous le nom entier.c dans votre répertoire personnel.
Saisissez dans un terminal ( dans le même répertoire ), la commande suivante :
cc entier.c -o entier.exe

Cette commande signifie :

Compile le fichier entier.c et crée un executable ( option -o ) qui s'appelera entier.exe
Pour lancer l'executable entier.exe, Saisissez dans un terminal ( toujours dans le même répertoire ), la commande suivante :
./entier.exe

4- Les différents types de données du Langage C

Neo futur — 2005-12-05T14:38:28Z

Les types de données simples

Les entiers : le type short et le type int
Les types short et int sont destinés à contenir un entier ( et un seul ) ; cependant, il peuvent se décliner de plusieurs manières.

Le programme qui suit ( taille_entiers.c ) vous permettra de savoir la taille en octets de chacun des types d'entier :

int main() { printf(" taille short = %d\n", sizeof( short )); printf(" taille unsigned short = %d\n", sizeof( unsigned short )); printf(" taille int = %d\n", sizeof( int )); printf(" taille unsigned int = %d\n", sizeof( unsigned int )); printf(" taille long int = %d\n", sizeof( long int )); printf(" taille unsigned long int = %d\n", sizeof( unsigned long int )); printf(" taille long long int = %d\n", sizeof( long long int )); printf(" taille unsigned long long int = %d\n", sizeof( unsigned long long int )); return(1); }

Sous Linux, ce programme donne :

bash-2.03$ ./taille_types.exe taille short = 2 taille unsigned short = 2 taille int = 4 taille unsigned int = 4 taille long int = 4 taille unsigned long int = 4 taille long long int = 8 taille unsigned long long int = 8

Cependant, sur d'autres systèmes, les tailles des types de données peuvent différer.

Il est donc important de préciser que les programmes qui procèdent a des décalages de bits ne sont pas nécessairement portables d'une plate-forme à une autre.

Un short pourra contenir, sous Linux, une valeur entre : -32768 et 32767

Un unsigned short pourra contenir, sous Linux, une valeur entre : 0 et 65535

Un int pourra contenir, sous Linux, une valeur entre : -2147483648 et 2147483647

Un unsigned int pourra contenir, sous Linux, une valeur entre : 0 et 4294967295

Un long int pourra contenir, sous Linux, une valeur entre : -2147483648 et 2147483647

Un unsigned long int pourra contenir, sous Linux, une valeur entre : 0 et 4294967295

Un long long int pourra contenir, sous Linux, une valeur entre : -9223372036854775808 et 9223372036854775807

Un unsigned long long int pourra contenir, sous Linux, une valeur entre : 0 et 18446744073709551615

Le programme min_max_types.c vous permettra de retrouver ces valeurs minimales quelle que soit votre plate-forme.
Les nombres a virgule flottante : le type float et le type double
Les types float et double sont destinés à contenir un nombre a virgule flottante ( et un seul ), c'est a dire un reel en langage purement mathématique.

Le programme qui suit ( taille_float.c ) vous permettra de savoir la taille en octets de chacun des types de reels du langage c :

int main() { float f; double d; long double ld; // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // Linux ne tolere pas les flottants non signes. // ********************************************* //unsigned float uf; //unsigned double ud; //unsigned long double uld; printf("taille en octets d'un float : %d\n", sizeof(float ) ); printf("taille en octets d'un double : %d\n", sizeof(double ) ); printf("taille en octets d'un long double : %d\n", sizeof(long double ) ); return(1); }

Sous Linux, ce programme donne :

bash-2.03$ ./taille_float.exe taille en octets d'un float : 4 taille en octets d'un double : 8 taille en octets d'un long double : 12

3- Les déclarations en language C

Neo futur — 2005-12-05T14:32:30Z

Les déclarations de variables en langage C

Lorsque vous avez besoin d'utiliser quelque chose en langage C, il faut d'abord déclarer ce quelque chose avant de pouvoir l'utiliser.

Ainsi une variable, une fonction, un pointeur ou une constante doivent être déclarés préalablement à leur utilisation.

Une variable est une boite dans laquelle on peut ranger une donnée, cette boite ne peut contenir que le type de données précis pour lequel cette variable a été déclarée ( un caractère ou un entier ... ).

La syntaxe générale de déclaration de variable est la suivante :

Exemples de déclarations suivies de l'initialisation :

( declare_affect.c ) :

#include <stdio.h> main() { char mon_caractere; // Declare une variable pouvant contenir 1 caractere char ma_chaine[20]; // Declare une variable pouvant contenir 20 caractères // ( En fait, 19 caracteres plus le caractere de fin de chaine '\0') int mon_entier; // Declare une variable pouvant contenir un entier mon_caractere = 'E'; printf(" mon_caractere = %c\n", mon_caractere ); // Pour initialiser une chaine de caracteres, qui est en fait un tableau // de caracteres, il est necessaire d'appeler une fonction qui va en fait // recopier les caracteres un par un strcpy(ma_chaine, "Ceci est ma chaine" ); printf("ma_chaine = |%s|\n", ma_chaine ); // La variable contient désormais "Ceci est ma chaine" ma_chaine[9]='t'; printf("ma_chaine = |%s|\n", ma_chaine ); // La variable contient désormais "Ceci est ta chaine" // car le 9eme caractere de la chaine ( en comptant a partir de 0 ) // a ete remplace par le caractere 't' // La variable contient desormais le caractere 'E' mon_entier=540; // La variable contient desormais la valeur 540 printf("mon_entier = %d\n", mon_entier ); }

Les déclarations de fonctions en langage C

Une fonction est un bloc de code qui va traiter des données, et renvoyer un résultat.

La syntaxe générale de déclaration de fonction est la suivante :

Une fonction peut aussi ne retourner aucun résultat et/ou ne recevoir aucun paramètre.

Exemples de déclarations de fonctions :

Les déclarations de pointeur en langage C

Un pointeur est une boite pouvant contenir l'adresse d'une autre boite.

Un pointeur, quel qu'il soit, est donc toujours une adresse, mais, lors de la déclaration de ce pointeur, on est obligé de dire de quel type est la donnée qui est contenue dans la boite dont l'adresse est stockée dans notre pointeur.

Ce qui signifie que l'on doit déclarer un pointeur qui contiendra l'adresse d'un entier ou l'adresse d'un char, par exemple.

La syntaxe générale de déclaration de pointeur est la suivante :

On peut déclarer ainsi un pointeur d'entier :

On peut déclarer ainsi un pointeur de caractere :

Les déclarations de constantes en langage C

Un constante est une boite dont le contenu ne peut pas être changé, il est fixé ( défini ) une fois pour toute.

La syntaxe générale de déclaration de constante est la suivante :

Exemples de déclarations de constantes

2- Les opérateurs du Language C

Neo futur — 2005-12-05T14:24:58Z

1. Les opérateurs arythmétiques

Tout d'abord les quatre opérations bien connues :

L'addition : le signe '+'
il est donc possible dans le programme C suivant ( test_plus.c ) de faire :

#include <stdio.h> int main() { int a = 3; int b = 7; int c = 0; printf("a=%d | b=%d |c=%d\n", a, b, c ); c = a+b; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 10 ( 3+7 ) a = a+c; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 13 ( 10+3 ) b= 3+50; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 53 ( 3+50 ) return(1); }
La soustraction : le signe '-'
il est donc possible dans le programme C suivant ( test_moins.c ) de faire :

#include <stdio.h> int main() { int a = 3; int b = 7; int c = 13; printf("a=%d | b=%d |c=%d\n", a, b, c ); b = c-a; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 10 ( 13-3 ) a = c-2; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 8 ( 10-2 ) c= 140-22; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 118 return(1); }
La multiplication : le signe '*'
il est donc possible dans le programme C suivant ( test_x.c ) de faire :

#include <stdio.h> int main() { int a = 3; int b = 7; int c = 0; printf("a=%d | b=%d |c=%d\n", a, b, c ); c = a*b; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 21 ( 3*7 ) a = c*2; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 42 ( 21*2 ) b= 3*4; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 12 return(1); }
La division : le signe '/'
il est donc possible dans le programme C suivant ( test_div.c ) de faire :

#include <stdio.h> int main() { int a = 30; int b = 0; int c = 2; printf("a=%d | b=%d |c=%d\n", a, b, c ); b = a/c; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 15 ( 30/2 ) c = b/5; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 3 ( 15/5 ) a= 300/50; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 6 return(1); }

Ensuite, un opérateur moins connu mais très utile, qui va nous permettre de connaître le reste d'une division entre deux entiers.
Le modulo : le signe '%'
il est donc possible dans le programme C suivant ( test_mod.c ) de faire :

#include <stdio.h> int main() { int a = 30; int b = 7; int c = 73; printf("a=%d | b=%d |c=%d\n", a, b, c ); b = a%b; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 2 ( 30/7=4 RESTE=2 ) c = c%7; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 3 ( 73/7 = 10 RESTE 3 ) a= 299%29; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 9 ( 299/29 = 10 RESTE 9 ) return(1); }

2. Les opérateurs et expressions d'affectation de variables

L'affectation simple : le signe '='
il est donc possible dans le programme C suivant ( test_affect.c )de faire :

#include <stdio.h> int main() { int a = 3; int b = 7; int c = 0; char caractere_saisi ='\0'; printf("a=%d | b=%d |c=%d\n", a, b, c ); c = a+b; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 10 ( 3+7 ) a = a+c; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 13 ( 10+3 ) b= 3+9; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 12 printf("saisissez un caractere SVP\n"); caractere_saisi = getchar(); printf("caractere_saisi = %c\n", caractere_saisi ); return(1); }
L'affectation avec incrémentation : le signe '=' precede d'un autre opérateur
il est donc possible dans le programme C suivant ( test_incr.c ) de faire :

#include <stdio.h> int main() { int a = 3; int b = 7; int c = 10; printf("a=%d | b=%d |c=%d\n", a, b, c ); c += 2; // equivalent a c = c+2 printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 12 ( 10+2 ) a -= 3; // equivalent a a = a-3 printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 9 ( 12-3 ) b *= 2; // equivalent a b = b * 2 printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 14 ( 7*2 ) c /= 3; // equivalent a c = c/3 printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 4 ( 12/3 ) return(1); }

Ce 'mélange des opérateurs' peut aussi s'appliquer aux opérateurs de manipulation de bits

3. Les opérateurs de comparaison

La comparaison d'égalité : le signe '=='
Cet opérateur va nous permettre de tester si deux variables sont égales. il est donc possible dans le programme C suivant ( test_egal.c ) de faire :

#include <stdio.h> int main() { int a = 3; int b = 7; int c = 3; printf("a=%d | b=%d |c=%d\n", a, b, c ); if ( a == c ) // ceci est vrai ( a est egal a c ) { printf(" a est egal a c\n"); }; if ( a == 3 ) // ceci est vrai ( a est egal a c ) { printf(" a est egal a 3\n"); }; if ( a == b ) // ceci est faux { printf(" a est egal a b\n"); } else { printf("a n est pas egal a b\n"); } if ( a == 20 ) // ceci est faux { printf(" a est egal a 20\n"); } else { printf(" a n est pas egal a 20\n"); } return(1); }
La comparaison de différence : l'opérateur ' !='
Cet opérateur va nous permettre de savoir si deux variables sont différentes. il est donc possible dans le programme C suivant ( test_diff.c ) de faire :

#include <stdio.h> int main() { int a = 3; int c = 10; printf("a=%d | c=%d\n", a, c ); if ( a != c ) // ceci est vrai ( a est different a c ) { printf(" a est different de c\n"); }; if ( a != 3 ) // ceci est faux ( a n'est pas different de 3 ) { printf(" a est different de 3\n"); } else { printf(" a n'est pas different de 3, donc a = 3\n"); } return(1); }
La comparaison d'infériorité : les opérateurs '<' et '<='
Ces opérateurs va nous permettre de savoir, respectivement, si une variable est 'inférieure'(<) ou 'inférieure ou égale'(<=) à une autre. il est donc possible dans le programme C suivant ( test_inf.c ) de faire :

#include <stdio.h> int main() { int a = 3; int b = 10; int c = 10; if ( a <= c ) // ceci est vrai ( a est inferieur ou egal a c ) { printf(" a est inferieur ou egal a c\n"); }; if ( b < c ) // ceci est faux ( b n'est pas inferieur a c ) { printf(" b est inferieur a c\n"); }; if ( a <= 3 ) // ceci est vrai ( a est inferieur ou egal a 3 ) { printf(" a est inferieur ou egal a 3\n"); }; if ( b < 10 ) // ceci est faux ( b n'est pas inferieur a 10 ) { printf(" b est inferieur a 10\n"); }; return(1); }
La comparaison de supériorité : les opérateurs '>' et '>='
Ces opérateurs va nous permettre de savoir, respectivement, si une variable est 'supérieure'(>) ou 'supérieure ou égale'(>=) à une autre. il est donc possible dans le programme C suivant ( test_sup.c ) de faire :

#include <stdio.h> int main() { int a = 3; int b = 10; int c = 10; printf("a=%d | b=%d |c=%d\n", a, b, c ); if ( b >= c ) // ceci est vrai ( b est superieur ou egal a c ) { printf(" b est superieur ou egal a c\n"); } if ( b > c ) // ceci est faux ( b n'est pas superieur a c ) { printf(" b est superieur a c\n"); } else { printf(" b n'est pas superieur a c\n"); } if ( a >= 3 ) // ceci est vrai ( a est superieur ou egal a 3 ) { printf(" a est superieur ou egal a 3\n"); } if ( b > 10 ) // ceci est faux ( b n'est pas superieur a 10 ) { printf(" b est superieur a 10\n"); } else { printf(" b n'est pas superieur a 10\n"); } return(1); }

4. Les opérateurs d'incrémentation/décrémentation

Ici, rien de bien sorcier, seulement deux opérateurs ( ++ et — ) :

L'opérateur '++'
Cet opérateur sert a incrémenter ( ajouter 1 a une variable ). il est donc possible dans le programme C suivant ( test_incr2.c ) de faire :

#include <stdio.h> int main() { int a = 3; printf("a=%d\n", a ); a++; // Maintenant a est egal a 4 printf("a=%d\n", a ); a=a+1; // Fait la meme chose que a++ ( incremente de 1 ) // Maintenant, a est egal a 5 printf("a=%d\n", a ); return(1); }
L'opérateur '—'
Cet opérateur sert a décrémenter ( enlever 1 a une variable ). il est donc possible dans le programme C suivant ( test_decr.c ) de faire :

#include <stdio.h> int main() { int a = 10; printf("a=%d\n", a ); a--; // Maintenant a est egal a 9 printf("a=%d\n", a ); a=a-1; // Fait la meme chose que a++ ( incremente de 1 ) // Maintenant, a est egal a 8 printf("a=%d\n", a ); return(1); }

5. Les opérateurs de manipulation des bits

Attention, là, ça se corse carrément, personne ne vous en voudra de passer a la suite et de revenir ici plus tard :

Les opérateurs logiques : '&', '|', ' ' et '^'

Ces opérateurs servent à manipuler les bits qui composent une variable. Les types de variables auxquels ces opérateurs s'appliquent sont :

int : Les entiers
long int : Les entiers longs
unsigned int : Les entiers non signés ( supérieurs a 0 )
char : un caractère
unsigned char : un caractère aussi

ATTENTION, ces opérateurs ne s'appliquent pas aux types float, double ( chiffres réels avec virgule ).

Le et binaire : l'opérateur '&'
Cet opérateur sert a ne garder que les bits qui se trouvent dans les deux variables auxquelles s'applique le et binaire. il est donc possible dans le programme C suivant ( test_et.c ) de faire :

#include <stdio.h> int main() { int a = 40; // en binaire, cela donne 00000000000000000000000000101000 int b = 0; int c = 0; int masque=8; // en binaire, cela donne 00000000000000000000000000001000 printf("a = %d\n", a); b=a&masque; // Permets d'eliminer tous les bits qui ne sont pas dans le masque // b est donc egal a 8, c'est a dire en binaire 00000000000000000000000000001000 // car le bit qui signifie 32 ( le 6eme en partant de la droite ) a ete elimine // ( il ne faisait pas partie du masque ) printf("b = %d\n", b); a=64; // en binaire, cela donne 00000000000000000000000001000000 printf("a = %d\n", a); b=a&masque; printf("b = %d\n", b); // Permets d'eliminer tous les bits qui ne sont pas dans le masque // b est donc egal a 0, cest a dire en binaire 00000000000000000000000000000000 // car le bit qui signifie 64 ( le 7eme en partant de la droite ) a ete elimine // ( il ne faisait pas partie du masque ) return(1); }
Le ou binaire : l'opérateur '|'
Cet opérateur sert a ajouter certains bits a une variable. il est donc possible dans le programme C suivant ( test_ou.c ) de faire :

#include <stdio.h> int main() { int a = 8; // en binaire, cela donne 00000000000000000000000000001000 int bits_a_ajouter = 32; // en binaire, cela donne 00000000000000000000000000100000 int c=0; printf("a = %d\n", a ); c= a|bits_a_ajouter; // On melange les bits des deux varaibles printf("c = %d\n", c ); // c est dorenavant egal a 40 car le bit demande a ete ajoute a ceux de a // cela donne en binaire : 00000000000000000000000000101000 return(1); }
Le ou EXCLUSIF binaire : l'opérateur '^'
Cet opérateur sert a enlever certains bits a une variable. La règle est la suivante : Si les deux bits de même rang sont a 0, le resultat sera a 0. Si les deux bits de même rang sont différents, le resulta sera a 1. Si les deux bits de même rang sont a 1 le resultat sera a 0

Pour résumer, seuls les bits de même rang qui sont différents, seront a 1, et tous les autres seront a 0.

il est donc possible dans le programme C suivant ( test_ou_ex.c ) de faire :

#include <stdio.h> int main() { char a = 24; // en binaire, cela donne 00011000 char masque = 48; // en binaire, cela donne 00110000 int c=0; printf("a = %d\n", a ); printf("masque = %d\n", masque ); c= a^masque; // On melange exclusivement les bits des deux varaibles printf("c = %d\n", c ); // c est dorenavant egal a // cela donne en binaire : 00101000 return(1); }
Le complément a un unaire : l'opérateur ' '
Cet opérateur sert a inverser chacun des bits de la variable.

Chaque bit a 0 sera mis a 1

Chaque bit a 1 sera mis a 0

il est donc possible dans le programme C suivant ( test_compl1.c ) de faire :

#include <stdio.h> int main() { unsigned char a = 2; // en binaire, cela donne 00000010 unsigned char b = 0; printf("a = %d\n", a ); b=~a; // On permute tous les bits // b est donc egal a 253 // c'est a dire en binaire : 11111101 // car chaque bit qui etait a 0 est maintenant a 1 // et chaque bit qui etait a 1 est maintenant a 0 printf("b = %d\n", b ); return(1); } <cadre> </li></ul> <h3> Les opérateurs de décalage de bits : '<<' et '>>' </h3> Ces opérateurs servent à décaler les bits qui composent une variable. <ul><li> Le décalage a gauche : l'opérateur '<<' On peut decaler a gauche tous les bits d'une variable comme dans le programme C suivant ( test_decal_gauche.c ) de faire : <cadre> #include <stdio.h> int main() { unsigned char a = 6; // en binaire, cela donne 00000110 unsigned char b = 0; printf("a = %d\n", a ); // On decale tous les bits d'une position vers la gauche b=a<<1; // Apres decalage a gauche ( d'une position ) // de tous les bits de a, b est egal a 12 // c'est a dire en binaire : 00001100 printf("b = %d\n", b ); // On peut aussi tout decaler de deux positions vers la gauche b=a<<2; // Apres decalage a gauche ( de deux positions ) // de tous les bits de a, b est egal a 24 // c'est a dire en binaire : 00011000 printf("b = %d\n", b ); return(1); }
Le décalage a droite : l'opérateur '>>'
On peut decaler a droite tous les bits d'une variable comme dans le programme C suivant ( test_decal_droite.c ) de faire :

#include <stdio.h> int main() { unsigned char a = 48; // en binaire, cela donne 00110000 unsigned char b = 0; printf("a = %d\n", a ); // On decale tous les bits d'une position vers la droite b=a>>1; // Apres decalage a droite ( d'une position ) // de tous les bits de a, b est egal a 24 // c'est a dire en binaire : 00011000 printf("b = %d\n", b ); // On peut aussi tout decaler de deux positions vers la droite b=b>>2; // Apres decalage a droite ( de deux positions ) // de tous les bits de b, b est egal a 6 // c'est a dire en binaire : 00000110 printf("b = %d\n", b ); return(1); }

Comme vous pouvez le constater :

Décaler d'une position a gauche équivaut à multiplier par deux
Décaler de deux positions a gauche équivaut à multiplier par quatre
Décaler de n positions a gauche équivaut à multiplier par ( 2 exposant n )
Décaler d'une position a droite équivaut à diviser par 2
Décaler de deux positions a droite équivaut à diviser par 4
Décaler de n positions a droite équivaut à diviser par ( 2 exposant n )
Les bits qui sortent du champ ( la taille de la variable ), sont irrémédiablement perdus.
Dans le cas du décalage a gauche, les nouveaux bits qui apparaissent a gauche sont initialisés avec des zéros.
Dans le cas du décalage a droite, les nouveaux bits qui apparaissent a droite sont initialisés avec des zéros.

1- Introduction au langage C

Neo futur — 2005-12-05T13:53:30Z

Qu'est-ce qu'un langage de programmation ?

Un langage de programmation est une syntaxe que l'humain va utiliser pour demander a l'ordinateur d'effectuer des taches ( afficher "BONJOUR" sur l'ecran , exemple en langage C ). Il suffit d'apprendre ces règles ( cette syntaxe ), et il devient possible de se faire obéir de l'ordinateur ( ca remets chacun a sa place, non ? ;-).

La syntaxe d'un langage de programmation, va nous donner différents outils pour communiquer avec l'ordinateur :

Des boites dans lesquelles on pourra ranger des données, des informations que l'on doit garder en mémoire pour pouvoir s'en resservir plus tard. Ces boites sont appelées des VARIABLES , et il en existe de différentes sortes, nous disposons de boites spécialement étudiées pour contenir :
- Des chiffres entiers ( sans virgule )
- Des chiffres réels ( avec virgule )
- Des caracteres de l'alphabet( lettres, chiffres et ponctuation ).
- Beaucoup d'autres types de données( adresse mémoire, structures de données ... ).
Des Instructions Conditionnelles , qui vont nous permettre de demander a l'ordinateur, de n'executer une tache que si les conditions demandées sont remplies.
EXEMPLE, pour afficher "BONJOUR" si il est plus de 16H00 : TANTQUE ( il n'est pas encore 16H00 ) -->ATTENDRE 1 seconde puis AFFICHER "BONJOUR"

( ceci est un algorithme, c'est a dire un raisonnemant logique,que nous devrons traduire dans un langage de programmation pour que l'ordinateur le comprenne )
Des structures de données , car nous disposons d'ores et déjà de différentes sortes de boites pour ranger divers types de données , mais il nous faut désespérément disposer d'un moyen de grouper des informations qui sont liées entre elle, cet outil s'appelle une Structure de Données .
EXEMPLE, pour relier les données concernant une table :

structure TABLE { hauteur_table_en_centimetres = 120; largeur_table_en_centimetres = 100; longueur_table_en_centimetres = 80; nombre_de_places_de_la_table = 6; prix_de_la_table_en_francs = 899; }

On pourra ensuite connaître la hauteur de la table en demandant :

table.hauteur_table_en_centimetres

ce qui nous donnera : 120

On pourra aussi connaître la largeur de la table en demandant :

table.largeur_table_en_centimetres

ce qui nous donnera : 100
Des fonctions , que d'autres gens ont déjà programmées pour nous ; par exemple une fonction AFFICHER ( que nous avons utilisée plus haut, mais qui en C s'appelle printf ) , va se charger d'écrire les données la ou nous voulons les écrire ( sur l'écran par exemple ).
De nombreuses autres fonctions sont disponibles en C, et vous pouvez écrire les votres, que vous pourrez ensuite réutiliser et donner aux autres personnes qui auront besoin de la même fonctionnalité que celle de votre fonction.

D'ou vient le langage C ?

Le langage C a été inventé au début des années 70 par Dennis RITCHIE, dans les laboratoires BELL AT&R, en s'inspirant d'un langage moins connu : le langage B.

L'histoire du langage C est intrinsèquement liée à celle d'UNIX ( Linux compris ) et d'internet, de TCP/IP ...

Le langage C est standardisé ( le même pour tout le monde ), et est normalisé par l'ANSI ( American National Standard Institute ) depuis 1982.

Mise a part la déplorable tentative de micro$oft de le dénaturer ( avec le C# ), le langage C est et reste standard, unique et portable.

Malgré l'apparition du langage C++ ( orienté objet ), les puristes et les perfectionnistes continuent essentiellement à développer en C, car ce langage est beaucour plus rapide et portable ( d'un ordinateur à un autre ) que tout langage à objet ( sauf peut-être java qui est extrêmement lent ).

Pourquoi le langage C reste-t-il toujours La Référence ?

Le langage C est la base syntaxique qui a inspirée de nombreux langages comme C++, Java, Perl, HTML, XML, Javascript ... ), ce qui fait que, si vous maîtrisez le langage C, il vous sera aisé d'apprendre de nombreux autres langages.

Tous les UNIX, tout Linux et tout le projet GNU, ainsi qu'internet, sont essentiellement fondés sont du langage C. L'avis de Kernighan sur la durabilité du lagage C ( plusieurs décénies, et ce n'est pas fini !-)) semble la meilleure : Le langage C représente un très bon compromis entre la compréhension humaine, et l'interpretation par l'ordinateur ( citation approximative ).

Il est important de noter qu'en langage C, on peut TOUT faire, sans véritables limitations, ce qui n'est pas toujours le cas dans les langages dits "objets".

De plus, on peut tout faire de manière efficace et rapide, à la compilation comme à l'exécution.

Il est de première importance de noter qu'en langage C, on peut faire de l'objet, et le faire efficacement et proprement, qui plus est ; pour illustration, veuillez découvrir la facon dont est implémenté GTK .

Le fameux programme "Hello World" en langage C

Neo futur — 2005-12-05T13:01:29Z

Le fameux programme « Hello World » en langage C

La fonction printf est une fonction C standard ( ANSI ), qui va écrire, sur la sortie standard ( l'écran ), le texte qui se trouve entre guillemets. Cette fonction dispose d'autres paramètres et permets de faire beaucoup plus qu'un simple affichage de texte.

Nous verrons plus tard d'autres utilisations de la fonction printf ( voir les entrées-sorties en langage C ) ; Si vous êtes impatient, et que vous avez la chance de travailler sous Linux ( ou un quelconque autre UNIX ), vous pouvez tout de suite saisir en ligne de commande 'man printf'.

Les deux premières lignes, qui commencent par :

sont des lignes de commentaires, ce qui se trouve derriere le // ne fait pas partie du programme, ne sera pas compilé, et ne sert qu'à commenter le programme.

La ligne qui commence par :

est une ligne d'inclusion, ce qui signifie que le code qui se trouve dans le fichier stdio.h sera inclus dans votre programme.

Il se trouve effectivement que pour pouvoir utiliser la fonction printf, il est nécessaire d'inclure ce fichier.

A chaque fois que vous utiliserez dans votre programme, une fonction C standard, il vous sera donc nécessaire d'inclure le fichier qui vous permettra d'utiliser le code de cette fonction.

POUR COMPILER ET EXECUTER CE PROGRAMME :

Sauvegardez le programme sous le nom hello.c dans votre répertoire personnel.
Saisissez dans un terminal ( dans le même répertoire ), la commande suivante :

cc -o hello.exe hello.c <cadre> Cette commande signifie : Compile le fichier hello.c et crée un executable ( option -o ) qui s'appelera hello.exe </li> <li> Pour lancer l'executable hello.exe, Saisissez dans un terminal ( toujours dans le même répertoire ), la commande suivante : <cadre> ./hello.exe

Allons un peu plus loin en communiquant avec l'ordinateur. Toujours dans un simple fichier texte, saisissez ( ou copiez/collez ) le texte suivant ( saisie.c ) :

// Exemple de programme C qui va demander le nom de l'utilisateur // Le nom saisi sera récupéré dans une variable puis reutilise // pour souhaiter la bienvenue a cet utilisateur dans // notre application #include void main(void) { // On declare la variable sz_nom_utilisateur pour pouvoir // y stocker le nom que l'utilisateur va saisir // On prevoit une taille maximum du nom d'utilisateur // de 127 caracteres ( ce qui nous laisse de la marge ). char sz_nom_utilisateur[128]; // On demande le nom d'utilisateur printf("Saisissez nom d'utilisateur SVP."); // On attends que le nom ait été saisi par l'utilisateur // pour le ranger dans la variable sz_nom_utilisateur scanf("%127s", sz_nom_utilisateur ); // Le nom a ete saisi par l'utilisateur et la fonction scanf // a rangé ce nom dans la variable sz_nom_utilisateur // On peut le récupérer dans cette variable pour saluer // notre utilisateur printf(" Bonjour %s, et bon courage dans votre apprentissage du langage C\n", sz_nom_utilisateur ); // Fin de l'application, on dit donc au revoir par pure politesse printf("\n AU REVOIR %s, ET A BIENTOT\n\n", sz_nom_utilisateur ); }

La fonction scanf va se charger d'attendre que l'utilisateur ait saisi son nom ( lequel lui a été demandé par la fonction printf ).

Dès que l'utilisateur aura appuyé sur la touche 'entrée' ( on l'appele aussi 'retour chariot' ), la fonction va récupérer ce qu'il a saisi et le placer dans la variable sz_nom_utilisateur ( le deuxième paramètre de la fonction ).

Le '%127s' qui apparait dans le premier paramètre signifie que l'on attends la saisie d'une chaine de caractères, qui ne doit pas dépasser 127 caractères.

La fonction printf est toujours là pour l'affichage de texte sur la sortie standard ( l'écran ), mais vous voyez ici apparaitre le : %s a l'endroit ou devrait apparaitre le nom que l'utilisateur a saisi précédemment, ainsi qu'un deuxième paramètre, le nom de la variable dans laquelle la fonction scanf a rangé ce nom qui a été saisi.

Vous remarquerez que, dans ce programme, le nombre de lignes de commentaires ( commencant par '//' ), est extrêmement important.

Ces commentaire doivent pouvoir vous aider a comprendre, ligne par ligne, ce que fait le programme.

Il est généralement admis qu'un bon programme doit contenir entre 30% et 50% de lignes de commentaires.

Un programme sans commentaires peut être tout aussi efficace, mais lorsque vous ( ou quelqu'un d'autre dans un contexte professionnel ou communautaire ) vous replongerez dans votre code, vous mettrez beaucoup plus longtemps a comprendre ce qu'il fait.

Les commentaires peuvent donc faire gagner beaucoup de temps.

La ligne :

est toujours là, c'est aussi elle qui vous permets d'utiliser la fonction scanf.

Pour compiler et executer votre programme :

* Sauvegardez le programme sous le nom saisie.c dans votre répertoire personnel.
* Saisissez dans un terminal ( dans le même répertoire ), la commande suivante : cc -o saisie.exe saisie.c Cette commande signifie : compile le fichier saisie.c et crée un executable ( option -o ) qui s'appelera saisie.exe
* Pour lancer l'executable saisie.exe, Saisissez dans un terminal ( toujours dans le même répertoire ), la commande suivante : ./saisie.exe

Bienvenue chez Ne0Futur =|{)

La compilation d'un programme en langage C sous Linux

6- Les instructions de contrôle du langage C

L'instruction if et l'instruction else

L'instruction for

L'instruction while

L'instruction switch

L'instruction do while

L'instruction break

L'instruction continue

5- Les entrées / sorties dans le langage C

Comment saisir et afficher un caractère

Comment saisir et afficher une chaine de caractère

Comment saisir et afficher un nombre entier

4- Les différents types de données du Langage C

Les types de données simples

3- Les déclarations en language C

Les déclarations de variables en langage C

Les déclarations de fonctions en langage C

Les déclarations de pointeur en langage C

Les déclarations de constantes en langage C

2- Les opérateurs du Language C

1. Les opérateurs arythmétiques

2. Les opérateurs et expressions d'affectation de variables

3. Les opérateurs de comparaison

4. Les opérateurs d'incrémentation/décrémentation

5. Les opérateurs de manipulation des bits

Les opérateurs logiques : '&', '|', ' ' et '^'

1- Introduction au langage C

Qu'est-ce qu'un langage de programmation ?

D'ou vient le langage C ?

Pourquoi le langage C reste-t-il toujours La Référence ?

Le fameux programme "Hello World" en langage C

Le fameux programme « Hello World » en langage C

POUR COMPILER ET EXECUTER CE PROGRAMME :

Pour compiler et executer votre programme :