Type de données, tableaux, opérateurs

29 Aug. 2010
Auteur : tonton nestor
Responsable : TrustRobot
Score ( voter ) :
Connexes : Même auteur | Même responsable | Historique
Le langage C est un langage algorithmique impératif.
Les mots clés s'écrivent en minuscule (main, printf, scanf). En C il n'y a que des fonctions, qui ont chacune un nom, des paramètres ou pas, elles renvoient chacune quelque chose ou pas et dont le corps est contenu entre {} [accolades]. Chaque programme C contient au moins une fonction int main(void), qui constitue l'entrée du programme.

Chaque instruction, se termine par un ; [point-virgule] et voici l'aspect d'une fonction : 
type_valeur_renvoyée nom_de_la_fonction(paramètres)
{
définition des variables
instructions
}
Avant d'être utilisées les variables doivent être déclarées pour en indiquer le type, ceci permet de réserver suffisamment de mémoire pour le programme. En C, il y'a 2 types fondamentaux : les entiers et les réels.

1. Les types élémentaires :

1.1 Les entiers :

On distingue 4 sortes d'entiers : Chacun de ces types pouvant être signé, ou non. Sauf indication contraire, ils sont signés.

Les entiers peuvent être représentés dans trois bases :

1.2 Les réels :

# On distingue 3 sortes de réels : Les réels sont évidement signés, ils peuvent être représentés de différentes manières :

1.3 Les caractères spéciaux :

1.4 Récapitulatif :

Notez qu'en C il n'y a pas de booléens, en général l'entier 0 code FAUX et un entier différent de 0 code VRAI.
(3 < 2) est évaluée à 0 et ('d' > 'b') renvoie 1.
Type de donnée Signification Taille (en octets) Plage de valeurs acceptée
char Caractère 1 -128 à 127
unsigned char Caractère non signé 1 0 à 255
short int Entier court 2 -32768 à 32767
unsigned short int Entier court non signé 2 0 à 65535
int Entier 2 (processeur 16 bits) -32768 à 32767 2147483647 à 2147483647
unsigned int Entier non signé 2 (processeur 16 bits) 0 à 65535 à 4294967295
long int Entier long 4 -2 147 483 648 à 2 147 483 647
unsigned long int Entier long non signé 2 0 à 4 294 967 295
float flottant (réel) 4 3.4*10-38 à 3.4*1038
double flottant double 8 1.7*10-308 à 1.7*10308
long double flottant double long 10 3.4*10-4932 à 3.4*104932

2. Les déclarations :

3. Les Opérateurs :

4. Les Tableaux :

4.1 Généralité sur les tableaux :

Un tableau est une suite d'éléments de même type dont les adresses mémoires sont consécutives. Pour déclarer un tableau, il faut indiquer, le type des éléments, le nom du tableau et le nombre de cases :
int tab[20]; /* tableaux de 10 entiers */ char chat[15]; /*tableau de 15 caractères */
Un tableau de 20 cases est indicé de 0 à 19, ainsi tab[2] correspond en fait au 3ème élément du tableau. Il est bien-sûr possible de parcourir un tableau à l'aide d'une variable ainsi tab[i], renverra le i+1 ème élément. Il y'a 2 manières d'initialiser un tableau :

4.2 Les tableaux à plusieurs dimensions :

Un tableau à plusieurs dimensions est en fait un tableau de tableaux, le formalisme associé permet cependant de les manipuler de manière transparente. On fournit d'abord la taille du tableau principal, puis la taille des tableaux sous-jacents récursivement.
Par exemple dans le cas d'une matrice, on donne d'abord le nombre de ligne puis le nombre de colonne : 
int tab[4][3]={ {1,2,3},
                {4,5,6},
                {7,8,9},
                {10,11,12}
};
int tab[3][4]={ {1,2,3,4},
                {5,6,7,8},
                {9,10,11,12}
};

4.3 Chaînes de caractères :

Il n'y a pas de type chaîne de caractère en C, mais en utilisant un tableau de caractères, on peut, les représenter et les manipuler. Lorsque j'écris : char chat[15]; je déclare un tableau pouvant contenir, 14 caractères et un 15 ème caractère \0. Concrètement je déclare une chaîne de 14 caractères maximum.
Notez que les cases du tableaux non utilisées sont remplacées par des \0. Voici un programme à compiler, qui donne quelques applications des chaîne de caractères : 
#include <stdio.h>
#include <string.h>

int main(void)
{

char Chaine1[10], Chaine2[10];
char Chaine3[10] = {'t','e','x','t','e',' ','3', '\0'};
char Chaine4[10]= "texte 4";

Chaine1[0]= 't';
Chaine1[1]= 'e';
Chaine1[2]= 'x';
Chaine1[3]= 't';
Chaine1[4]= 'e';
Chaine1[5]= ' ';
Chaine1[6]= '1';
Chaine1[7]= '\0';

printf("\n Entrez une chaîne de caractères : ");
scanf("%s",Chaine2);
printf("\n la chaîne 1 passée en dur dans le programme : %s", Chaine1);
printf("\n la chaîne 2 passée depuis le clavier : %s", Chaine2);
printf("\n la chaîne 3 passée en dur dans le programme : %s", Chaine3);
printf("\n la chaîne 4 passée en dur dans le programme : %s \n", Chaine4);
return(1);
}
Vous pouvez le compiler et l'exécuter, il vous affichera :
Entrez une chaîne de caractères : texte_2 la chaîne 1 passée en dur dans le programme : texte 1 la chaîne 2 passée depuis le clavier : texte_2 la chaîne 3 passée en dur dans le programme : texte 3 la chaîne 4 passée en dur dans le programme : texte 4

5. Les Structures :

Une structure comme son nom l'indique est une juxtaposition d'objets de types différents ou pas. La cas d'école sur les structures est bien-sûr les complexes. Vous pouvez définir un complexe par :
struct complexe { float reel; float imaginaire; };
On peut alors déclarer des complexes par : struct complexe z,z1={3.0,4.0},z2={1.0,2.0}; Affecter des valeurs : z.reel=z1.reel + z2.reel; z.imaginaire = 1.0; Les mettre dans un tableau : struct complexe tab_comp[10]; Accéder à une valeur du tableau : tab_comp[1].reel=2.0;

«« Précédent Suivant »»