Le C est un langage de programmation de haut niveau très répandu. Il nécessite l'utilisation d'un compilateur pour obtenir un programme exécutable.
Toutes les instructions en C seront terminées par des points-virgules (;). Si on doit regrouper plusieurs instructions ensemble, alors on doit les mettre entre accolades ({}). Pour introduire des commentaires il faut les mettre ainsi /* commentaires */. On peut aussi les précéder de deux barres (//) si ils sont sur une ligne.
Ils existent différents types d'entier en C : char(codé sur 1 octet), short, int, long. Pour connaitre leur taille en octet utilisez la fonction sizeof : sizeof(short). Ces entiers peuvent être seulement positifs (unsigned : non signés). Chaque fois qu'on utilisera une variable en C, il faudra l'avoir déclarée.
unsigned short Nombre_Entier; //déclare un nombre entier non signé qui va de 0 à 65535 (en général).
unsigned char Caractere; //déclare un nombre entier non signé qui va de 0 à 255.
char N1,N2,N3; /* déclare trois nombres entiers signés qui vont de -128 à 127.*/On remarque dans ces exemples que le caractère _ est accepté dans les identificateurs, ainsi que les chiffres (si ils ne prennent pas la place du 1er caractère). De plus on peut déclarer plusieurs types identiques en même temps, en les séparant par des virgules. Enfin, puisque le type char est codé sur 1 octet, il peut servir de caractère.
Note : Il existe d'autres type de base qui ne sont pas des entiers (float, double, long double). Ainsi que des types qui sont fait à partir de ces types de bases, provenant des librairies (FILE de stdio.h , BITMAP de allegro.h, etc...).
Si on veut créer des tableaux, alors on doit donner ses dimensions lors de la déclaration.
unsigned short Element[5][10]; //déclare un tableau de 50 éléments.
char Chaine_de_caracteres[10]; // déclare un tableau de 10 éléments.Le premier exemple nous montre un tableau à 2 dimensions. Le second nous montre un cas intérressant, où le tableau de 10 entiers constitut une chaîne de caractère. Dans un tableau à une dimension, le 1er élément est Identificateur [0] le Nème élément est Identificateur[N - 1]. Ceci est généralisé pour les tableaux multidimensionnels.
Un pointeur est une adresse, par exemple, si on déclare ceci : short Nombre; unsigned char Chaine[50]; char *Truc;, alors :
Truc n'est pas un caractère, mais un pointeur sur un caractère : on a mis une étoile devant. Pour avoir le caractère pointé par Truc, il faut écrire Truc[0], comme pour les Tableaux. Ainsi, le 10e caractère après celui pointé par Truc est Truc[9].
Les pointeur peuvent aussi pointé sur autre chose que des variables, par exemple sur un fichier ou sur rien du tout (NULL).
Ils existent divers opérateurs qui permettent de travailler avec les variables déclarées. Voici quelques exemples (où N et M sont des nombres) :
Voici enfin la dernière chose importante à connaître avant le premier programme. Les fonctions sont construites ainsi :
Type_de_la_fonction Nom_de_la_fonction(Type Argument1, Type Arg2, Type Arg3...){bloc d'instructions}Si la fontion n'a pas de type, il faut alors lui mettre void. Il n'est pas nécessaire de déclarer les fonctions, sauf si elles se trouvent après la fonction principale.
/* Fonction qui retourne le carré de nombre */
unsigned short carre(char nombre)
{
return nombre*nombre;
}
/* Fonction qui élève nombre au carré */
void Elever_au_carre(int *nombre)
{
nombre[0]*=nombre[0];
}Après ces 7 premières parties, on peut se lancer dans notre premier programme.
#include <conio.h>
#include <stdio.h>
#include <dos.h>
int main()
{
clrscr(); //Appelle la fonction clrscr qui efface l'écran.
printf("Hello world !"); //Affiche du texte à l'écran.
delay(1000); //suspend 1000 millisecondes (1 seconde) le programme.
}Elles sont construites ainsi : if(condition){bloc d'instructions}
Si la condition est vrai alors le programme effectue l'instruction (ou le bloc d'instructions entre accolades). Si elle est fausse il peut effectuer les instructions d'un else facultatif.
#include <conio.h>
#include <stdio.h>
#include <dos.h>
int main()
{
unsigned char Reponse; // Déclare le nombre Reponse dans main();
clrscr(); //Efface l'écran
printf("Comment allez-vous ?\n1 Bien \n2 Pas Bien\n\n"); // Affiche la question. \n est le saut de ligne
scanf("%d",&Reponse); // Attends le saisie d'un nombre
if(Reponse==1)
printf("Tant mieux !"); // Si on rentre 1
else
{
if(Reponse==2)printf("Tant pis !"); // Si on rentre 2
else printf("Je n'ai pas compris votre réponse..."); // ni 1 ni 2
}
delay(2000); // Attend 2 secondes
}switch(Reponse)
{
case 1: printf("Tant mieux !");break;
case 2: printf("Tant pis !");break;
default:printf(Je n'ai pas compris votre réponse...");break;
}Dans un programme, on doit souvent répéter plusieurs fois une même suite d'instrutions. Ainsi on peut se servir de 3 boucles différentes en C, mais qui sont en faite équivalentes, le choix dépend de la situation d'utilisation. Voici ces 3 boucles :
for(N=0;N<10;N++)printf("%d\n",N+1);// Affiche le nombre (indiqué par %d) N+1 puis saute une ligne.for(N=8;N>5;N--);// N prend les valeurs: 8-7-6-5for(N=10;N<30;N+=5);// N prend les
valeurs:10-15-20-25-30for(N=2;N!>256;N*=2);// N prend les
valeurs:2-4-8-16-32-64-128-256for(N=2;N<=256;N*=N);// N prend les
valeurs:2-4-16-256-65536for(N=0;N<3;N++)
for(M=0;M<6;M++)
{
gotoxy(N*2,M*4);
printf("N×6+M = %d",N*6+M);
}
;Les boucles se lisent ainsi : N prend une valeur de 0 à 2, pour chacune de ces 3 valeurs de N, M prend des valeurs de 0 à 5. Ce qui donne :
| Valeurs de N | 0 | 1 | 2 |
| Valeurs de M | 0, 1, 2, 3, 4, 5 | 0, 1, 2, 3, 4, 5 | 0, 1, 2, 3, 4, 5 |
#include <conio.h>
#include <stdio.h>
#include <bios.h>
/* Echange les nombres pointés par Entier1 et Entier2. */
void Echanger(int *Entier1, int *Entier2)
{
int Entier3;
Entier3=Entier1[0];Entier1[0]=Entier2[0];Entier2[0]=Entier3;
}
/* fonction principale */
int main()
{
int Nombre[5],N,ok;
/* Saisie des 5 nombres */
clrscr();
printf("L'ordinateur va ranger 5 nombres dans l'ordre croissant par tri à bulle...\n\n");
for(N=0;N<5;N++)
{
printf("Rentrez le Nombre N°%d ",N+1);Nombre[N]=0;
scanf("%d",&Nombre[N]);// Lecture du (N+1)e nombre.
}
/* Debut du tri à bulle */
do
{
for(ok=1,N=0;N<4;N++)
{
if(Nombre[N]>Nombre[N+1])
{// cas où deux nombres successifs ne sont pas dans le bon ordre
Echanger(&Nombre[N],&Nombre[N+1]);ok=0;}
}
}
while(!ok);
/* Affichage des résultats */
clrscr();// Place le curseur en haut de l'écran
printf("Voici les nombres entiers classés par ordre croissant :\n\n");
for(N=0;N<5;N++)printf(" %d",Nombre[N]);
/* Boucle d'attente */
printf("\n\nAppuyer sur espace pour quitter...");
while(getkey()!=32);// Attend l'appuie de la touche espace.
}Il n'existe pas en C un type « chaîne de caractères », pour résoudre ce problème, voici comment on procède :
unsigned char Chaine[10]; // Déclaration d'un tableau de 10 types « char ».Il existe des fonctions pour manipuler les chaînes dans la librairie <string.h>. Jetez donc un coup d'oeil la dessus...
