C-V [76-93]

C-V : sommaire

Types (suite)

C-V 1

Types (suite)

C-V 2

Tableaux (1)

Aggrégation d'entités d'un MEME TYPE (représentée par un bloc contigu de mémoire) :

Définitions :

// Définition de tableaux à une dimension

int t[10];

// Définition de tableaux à deux dimensions

float t[5][10];
Définitions et initialisation :

// Tableau de taille 4 déterminée

// par la liste d'initialisation

int t[]={0,1,2,3};

intmatrice[2][3] = {{1,2,3},{4,5,6}};

Remarques : la taille est définitivement fixée à la compilation.

C-V 3

Tableaux (2)

Utilisation : utilisation de l'opérateur d'indexation [...]

int `t[10];`
`-->` `t[0] t[1] ...t[9] THE END !!!`

float `t[5][10];`
`-->`	`t[0][0] t[0][1] ...t[0][9]`
`t[1][0] t[1][1] ...t[1][9]`
`...`
`t[4][0] ...t[4][9] THE END !!!`
`...`
int `i,j;`
for `(i=0;i<5;i++) {`
for `(j=0;j<10;j++)`
printf(``%f ``,t[i][j]);
printf(```\n'');`
`}`

Remarques :
- les indices varient de 0 jusqu'à taille - 1 ;
- le dépassement de borne n'est pas vérifié ;

C-V 4

Chaînes de caractères

Pas de type spécifique : une chaîne est simplement un tableau de caractères :

// chaîne caractères de taille 5

char ch[] = "toto" ;

// tableau de caractères

char ch1[100];

// chaîne de caractères de taille 5

// dans un tableau de caractères de taille 10

char ch2[10] = "titi" ;

// d'autres chaînes de caractères

char ch3[] = "Une jolie chaîne\n" ;

char ch4[] = "Une avec un \¨ ou un \\." ;

Convention : On marque la fin logique d'une chaîne de caractères par le caractère nul ('\0')
Þ taille d'une chaîne = longueur + 1.

C-V 5

Manipulation des chaînes de caractères

Utilisation de la bibliothèque standard du C.
La déclaration des fonctions est disponible dans <string.h>
Les fonctions suivantes sont disponibles :
- Longueur d'une chaîne : int strlen(const char *s)
- Comparaison de chaînes :
  int strcmp(const char *s1, const char *s2)
  int strncmp(const char *s1, const char *s2, int n)
- Concaténation de chaînes :
  char *strcat(char *dest, const char *orig)
  char *strncat(char *dest, const char *orig, int n)
- Copie de chaînes :
  char *strcpy(char *dest, const char *orig)
  char *strncpy(char *dest, const char *orig, int n)
- ...

C-V 6

Tableaux et pointeurs

Un tableau d'entités de type Z est un pointeur constant sur le type Z. Ex : une chaîne de caractères est un pointeur constant sur caractère.
le nom du tableau est un pointeur implicite sur son premier élément.

int *pi, t[10], u[]={1,2,3};

// t et u sont deux pointeurs sur des entiers

// t est l'adresse de t[0]

// u est l'adresse de u[0]

pi=t; // OK

t=pi; // Erreur car t est un pointeur CONSTANT

t=u; // Erreur car t est un pointeur CONSTANT

-->t[3]º pi[3] º *(t+3) º *(pi+3)

Remarque : pour les opérations arithmétiques avec les pointeurs, l'unité est la taille de l'objet pointé.

C-V 7

Pointeurs et tableaux

`// Définition d'un pointeur sur caractères`
`// initialisé par une chaîne de caractères`
char `*s = "bonjour";`
char `u[]="salut";`
`-->s[3]`	`º` `(s+3)` `º` `("bonjour"+3)`
`º` `"bonjour"[3]`
`s = u; // OK`
`u = s; // Erreur car u est un`
`// pointeur CONSTANT`

double `X, T[10], pT1, pT2;`
`pT1=&T[4];`
`X=*(pT1+1);`	`// Mise à l'échelle`
`pT2=&T[7];`
`i=pT2 - pT1; //i vaut 3`
`// Par contre, pT1 + pT2`
`// est interdit`

Attention : Une définition de tableau réserve implicitement la place mémoire pour TOUS les éléments du tableau...rien de tel avec les pointeurs (cf. gestion mémoire).

C-V 8

Tableau en argument d'une fonction

La syntaxe pour le passage des tableaux est :

int sort (int base[], inttaille) ;
L'écriture suivante est possible, MAIS attention dans certaines situations ... :

int sort (int *base, inttaille) ;

C-V 9

Retour d'une fonction et tableaux

une fonction NE PEUT PAS retourner un tableau.
Solution 1 : retourner un pointeur, MAIS attention la valeur doit exister après l'exécution de la fonction.
Solution 2 : passer le tableau résultat en argument de la fonction. (cf. les fonctions de manipulation de chaînes de caractères).

C-V 10

Énumérations

Ensemble de valeurs entières représentées par des identificateurs.

enum feux {vert, orange, rouge};

feux f1, f2;

f1=vert;

Utilisé souvent avec l'instruction switch :

switch	`(f1) {`
case `vert : passer();` break`;`
case `orange : accelerer();` break`;`
case `rouge : freiner();` break`;`
`}`

Remarques :
- Il faut penser à feux comme à un nouveau type (en C ce nouveau type est enum feux),
- Le premier identificateur reçoit la valeur 0, le suivant la valeur 1, et ainsi de suite, SAUF SI :
enum taille {petit=7,moyen,grand=10,geant};

C-V 11

Structures

Aggrégation d'entités pouvant être de type différent.

Définition

struct personne {

char Nom[20];

short Age;

};

personne p1, p2;

// en C structpersonne p1;
Initialisation

personne p3={"Jean",36};
Accès aux champs par l'opérateur d'accès . :

short i;

i = p3.Age;

p2.Age=3;

Remarques :

- Penser à personne comme à un nouveau type (en C le nouveau type est struct personne).
- Taille mémoire = å tailles des différents champs.

C-V 12

Unions

Similaire à une structure... sauf qu'une seule variable est stockée à un instant donné.

union realint {

double Rea;

int Int;

} x;

...

realint x;

x.Rea=3.14;

x.Int=30;

Problème : se souvenir du champ qui est utilisé !!!

Remarques :

- Penser à realint comme à un nouveau type (en C le nouveau type est union realint).
- Taille mémoire = Max taille des différents champs.

C-V 13

Exemple d'unions

enum _utype {INT,FLOAT,STRING};

struct{

char *name; // nom du symbole

int flags; // indicateur

_utype utype; // type du symbole

union { // valeur du symbole

int ival; float fval; char *sval;

} u;

} symtab[NSYM]; // table de symboles

...

switch (symtab[i].utype) { // selon le type

case INT :

symtab[i].u.ival=2; break;

case FLOAT :

symtab[i].u.fval=2.3; break;

...

default :

printf("Erreur, type inexistant\n");

}

C-V 14

Structures, unions et pointeurs

struct noeud {

int Valeur;

noeud *FilsGauche;

noeud *FilsDroit;

}

noeud arbre1,arbre2,arbre3;

...

arbre1.FilsDroit = &arbre2;

arbre1.FilsDroit->FilsGauche = &arbre3;

...

C-V 15

Structures, unions et fonctions

Structure en argument d'une fonction : préférer un passage par référence pour limiter la taille des arguments de la fonction,
Structure en retour d'une fonction : le retour d'une fonction peut être une structure ou une union.

C-V 16

Structures, unions et tableaux

char c;

// Définition d'un tableau de 10000 entités

// de type structure de personnes.

personne grosfichier[10000];

c=grosfichier[3031].Nom[0];

C-V 17

Définition de nouveaux types (1)

typedef á typeñ nouveau_nom ';'

Définition d'un nouveau nom à un type existant. Ne crée pas de nouveau type :

typedef char Message[50] ;typedef int Longueur;typedef int Poids;typedef struct personne Personne;typedef union realint realint;typedef enum feux feux;

Remarque : Possibilité d'utiliser le même identificateur que celui utilisé pour déclarer la structure (ou l'union ou l'enum). Possibilité aussi de grouper typedef avec la définition du type :

typedef enum Note {a, b, c, d, e} Note;

C-V 18

Définition de nouveaux types (2)

En C++ uniquement, le nom d'un struct, union, enum ou class est un nom de type.

struct personne {

int age;

int taille;

chaine nom;

personne * suivant;

// struct personne * suivant; // en C

};