Manipulations de variables

Typage et éclaration de variables

Typage et éclaration de variables

Il est possible de combiner ces types avec des mots clef:

float maVariable;
					int ceciEstUnEntier;
					unsigned int ceciEstUnEntierSuperieurAZero;
					char ceciEstUnCaractère;
					long int ceciEstUnEntierLong;

long long int ceciEstUnEntierTresLong; //C99
					long ceciEstUnEntierLong;
					double ceciEstUnDouble;
					long double ceciEstUnDoubleLong = 1.3421;// Declare + init.

Booléen

Attention ! Il n’y a pas de type booléen en C89/90. Depuis C99 on peut utiliser:

#include<stdbool.h>
					bool unBoolean =  // (en fait true==1 et false==0)

D'une manière généralle:

• toute valeur différente de 0 est considérée comme vraie
• 0 ou NULL sont considérés comme faux

Taille des variables

La taille des variables dépend des platformes et compilateurs. Pour connaitre la taille d'une variable:

• Utiliser l'opérateur sizeof(obj), obj peut être un type ou un nom de variable
• les fichiers header "limits.h" et "float.h" donne les limites des types:
  • CHAR_MIN: valeur minimum d'un char
  • UINT_MAX: valeur maximum d'un int
• en norme C99, "stdint.h" contient des types avec taille explicite:
  • int8_t, int16_t, int32_t
  • uint8_t, uint16_t, uint32_t

Règles sur les variables

Les noms de variables doivent suivre les règles suivantes:

• doit commencer par une lettre ou un _ ;
• peut comporter uniquement lettres, chiffres et _;
• ne doit pas être un nom déjà existant (nom de fonction, if, sizeof, ...);
• il est fortement conseillé d’utiliser des noms de variable claire.

N’oubliez pas d’initialiser les valeurs des variables !

Portée d’une variable:

• Si elle est déclarée entre deux accolades {}, la variable ne sera accessible que entre ces accolades
• Si une variable est déclarée hors de toute accolade (hors de toute fonction) elle est alors globale et accessible de partout. A éviter.

Opérateur usuels

Question

Etant donnée la definition de fonction suivante:

function test_if_2(int a) {
					  if(a = 2)
						return 1;//or true
					  else
						return 0;//or false
					}

Que retourne l'appel suivant ?

test_if_2(3)

Opérateurs usuels

Il est possible de combiner les opérateurs arithmétiques et logiques avec l’affectation:

int y;
					y = 3;
					y += 4;//Equivalent à y = y + 4;
					x <<= 2;//Equivalent à x = x << 2;

Il existe un opérateur d’incrément / décrément (++ et --):

int x, i = 0;
					i++; //equivalent à i = i + 1
					i--; //equivalent à i = i - 1
					x = ++i; //x vaut 1 car l'incrément est fait avant l'affectation
					x = i++; //x vaut toujours 1 car l'incrément est fait après l'affectation
					

L’ordre de priorité des opérateur est:

• l’ordre habituel pour les opérateur arithmétiques;
• modifiable grâce au parenthèses ().

Conversion de types

Dans un calcul le type des variables détermine le type du résultat:

• si un calcul implique des variables de même type le résultat sera de ce type;
• si un calcul implique des variables de types différents le type « le plus général » est choisi.

						
int xInt = 3, resInt;
float xFloat = 3, resFloat;
char xChar = 3;
resInt = xInt / 4; //resInt vaudra 0 car le calcul est entier
resFloat = xInt / 4; //resFloat vaudra 0.00 car le calcul est entier
resFloat = xInt / 4.; //resFloat vaudra 0.75 car 4. est un float
resFloat = xFloat / 4; //resFloat vaudra 0.75 car xFloat est un float
resInt = xFloat / 4; //resInt vaudra 0 (cas resInt est un entier)	
resInt = xChar + 2; //Convertion automatique et possible (resInt vaudra 5)
						
					

Casting (moulage)

Le casting permet de forcer la conversion de type

esFloat = (float) xInt / 4; // resFloat vaudra 0.75 car x est convertit en float
resFloat = (float) (xInt / 4); /* resFloat vaudra 0.00 car le calcul entier est fait
                                  avant conversion */
resInt = (float) xInt/ 4; // resInt vaudra 0 car resInt est un entier
					

Question

Quel est le problème avec les calculs suivants ?

int i; long int l; float f; char c; unsigned char uc;

c = -100;
uc = c;

c = 'ï'; //code ascii = 239
uc = c;

l = 320254468;
f = 45879651324476.5;
i = l * f;
					

Les tableaux et chaines de caractères

Déclaration des tableaux

Les tableau sont:

• de type unique;
• indicés de 0 à N-1 pour un tableau de N éléments;
• organisés de manière contigüe en mémoire;
• statiques ou dynamiques (cf. pointeurs et C99).

Décalaration d'un tableau:

#define TAILLE_MAX 10
					int tableauDEntiers[TAILLE_MAX];
					double tableauDeDoubles[TAILLE_MAX];

Utilisation des tableaux

Affecter et lire les valeurs des tableaux:

// Initialization du tableau
					for(int i=0; i<TAILLE_MAX; i++)
					  tableauDEntiers[i] = i+1;
					
					// Alternative mais uniquement lors de la declaration
					int tableauDEntiers[TAILLE_MAX] = {1,2,3,4,5,6,7,8,9,10};
					
					// Affichage du tableau
					for(int i=0; i<0; i++)
					  printf("Le tableau contient à l'indice %d la valeur %d", i, tableauDEntiers[i]);

Attention !

Attention aux indices des tableaux !

Hors des limites on attends un comportement indéfini:

• Au mieux tout fonctionne correctement.
• Eventuellement une erreur de segment.
• Au pire la valeur d’une autre variable est modifiée et on peut obtenir des erreurs importantes.

Tableau à N dimensions

//Lignes et colonnes sont arbitraires
					#define NB_LIGNES 3
					#define NB_COLONNES 5
					#define NB_MORE 7
					
					double tab2D[NB_LIGNES][NB_COLONNES];
					float tab3D[NB_LIGNES][NB_COLONNES][NB_MORE];
					float tab4D[NB_LIGNES][NB_COLONNES][NB_MORE][NB_MORE];
					
					for(i=0;i<NB_LIGNES;i++)
					  for(j=0;j<NB_COLONNES;j++)
						tab2D[i][j] = 0.0;

L'organisation en mémoire reste linéaire !

Chaine de caractères

Il n’y a pas de type chaine de caractère (string) en C, pour cette raison on utilise des tableaux de caractères.

Une chaine de caractères se termine toujours par le caractère “\0”:

• il faut donc penser à réserver une place pour ce caractère dans le tableau;
• tout ce qui suit le “\0” est ignoré;
• si il n’y a pas de “\0” la chaine de caractères est sans fin (donc plus que la taille du tableau).

Manipulations des chaines

char maChaine[8] = "C cool!";/* \0 est ajouter après la chaine (pensez a
													 reserver de la place) */
					char maChaine2[] = "C cool!";// Alloue automatiquement la bonne taille
					printf("%s\n", maChaine2); //Affiche la chaine
					maChaine[1] = '\0';// '' pour un caractère et "" pour une chaine
					printf("%s\n", maChaine); //Affiche "C"

Il existe des fonctions de manipulation de chaines dans la librairie string (inclure string.h), par exemple:

• strncpy(dest, src, n), copie n caractère de la chaine src vers dest;
• strlen(str), retourne la taille de la chaine sans compter ‘\0’;
• strcmp(str1, str2), retourne 0 si les deux chaines sont identiques;
• strncat(dest, src, n), ajoute src à la fin de dest (enlève le ‘\0’), copie au maximum n bytes de src.

Entrée / sortie console

printf(texteEtFormat, variable1, variable2, ...)

scanf(texteEtFormat, *variable1, *variable2, ...)

Entrées / sortie console

liste des principaux spécificateur (man printf pour une liste complète):

Entrées / sortie console

On utilise les combinaisons de symboles suivantes pour les caractères spéciaux:

Entrées / sortie console

int getchar( void )

int putchar( int car )

char* fgets ( char* string, int size, stdin ) //!!!

int puts (const char* string)

Exemple d'entrées / sorties

#include<stdio.h>
					/* La fonction main est toujours la première fonction du programme à être
					appellée lors que l'execution*/
					int main(void)
					{
					  float inputFloat;
					  char inputChar;
					  int nbCorrespondance;
					
					  //Entrée de l'utilisateur pour un float et affichage du
					  //float de différente manières
					  printf("Veuiller entrer un float:\t");
					  scanf("%f", &inputFloat);
					  printf("Affichage de l'entree sous forme de float: %f\n", inputFloat);
					  printf("Idem avec 2 digits apres la virgule: %.2f\n", inputFloat);
					  printf("Idem avec au moins 6 caractères: %6.2f\n", inputFloat);
					  printf("Notation scientifique: %e\n", inputFloat);
					  printf("Affichage de l'entree sous forme d'entier %d\n", inputFloat);
					
					  //Boucle tant que l'utilisateur n'appuye pas sur 'enter' uniquement
					  do
					  {
						//Entrée de l'utilisateur pour un caractère
						//avec effacement du buffer d'entrée clavier
						printf("Veuiller entrer un caractere: ");
					
						while((inputChar = getchar()) != '\n' && inputChar != EOF);
						inputChar = getchar(); //could also use scanf("%c", &inputChar);
					
						//Si le caractère est valide l'afficher sous forme d'entier non signé
						if(inputChar != '\n')
						  printf("Le code ASCII de %c est %u\n", inputChar, inputChar);
					  } while(inputChar != '\n');
					  return 0;
					} //end main

Question

Dans quel cas ce code provoque des erreurs?

#include<stdio.h>
					#define TAILLE_MAX 3
					
					void affiche_chaine(char*, int);
					
					int main(void)
					{
					  int valeur1 = 1;
					  char chaine[TAILLE_MAX] = {'a', 'b', '\0'};
					  int valeur2 = 2;
					
					  // Affiche l'état de la mémoire pour les variable ci-dessus
					  printf("Valeur1:\tAdresse: %x\tValeur:%d\n", &valeur1, valeur1);
					  affiche_chaine(chaine, TAILLE_MAX);
					  printf("Valeur2:\tAdresse: %x\tValeur:%d\n", &valeur2, valeur2);
					
					  // NE JAMAIS UTILISER GETS
					  gets(chaine);
					
					  // Affiche l'état de la mémoire pour les variable ci-dessus
					  printf("Valeur1:\tAdresse: %x\tValeur:%d\n", &valeur1, valeur1);
					  affiche_chaine(chaine, TAILLE_MAX);
					  printf("Valeur2:\tAdresse: %x\tValeur:%d\n", &valeur2, valeur2);
					}

Exécution de programme

La fonction main

La fonction main est le point d'entré du programme et a l’entête suivante:

int main (int argc, char *argv[])

Exemple de fonction main

#include<stdio.h>
					#include<stdlib.h>
					int main(int argc, char *argv[])
					{
					  int i, sum = 0;
					  if(argc != 0)
						printf("Le nom du programme est: %s\n", argv[0]);
					  if(argc > 1)   {
						//Sum the inputs
						for(i=1;i < argc; i++) {
						  //Affiche le paramètre traité
						  printf("Param %d: %s\n", i, argv[i]);
						  //Convert the parameter to a number and sum it
						  sum += atoi(argv[i]);
						}
					  }
					  return sum;
					}

Variables d'environements

char* getenv (const char *name)

int putenv (char *string)

Compiler et lier un programme

Compiler un programme

gcc appelle automatiquement ld, pour compiler et lier un programme il suffit donc d’utiliser gcc:

$ gcc prog.c -o prog

Les options principales de gcc:

Compiler un programme

Lorsque gcc trouve une option qu’il ne connait pas il passe cette option et les suivantes a ld.

Il faut toujours mettre les options ld à la fin:

Les libraires portent le nom libnom et ce trouvent généralement dans:

/usr/lib
					/usr/lib64

Par exemple la librairie svn s’appelle “libsvn” et pour la lier on utilise:

$ gcc monClientSVN.c -o clientsvn -l svn

Debugger un programme

$ gdb monexecutable -c core

Debugger un programme

$ gdb monProg

Les pointeurs

Concept

Equivalence pointeurs ↔ tableaux

Un tableau (e.g. chaine de caractère) est représentable par un pointeur et une taille.

int main(int argc, char* argv[]) {
					  char *chainePtr;
					  char chaineTab[] = "Je suis bien content !";
					  long long int *intPtr, i;
					  long long int intTab[TAILLE_TAB];
					
					  //Initialisation du tableau d'entiers
					  for(i=0;i<TAILLE_TAB;i++)
						intTab[i] = i+1;
					
					  //Mettre les pointeurs sur les tableaux
					  intPtr = intTab; //equivalent à intPtr = &intTab[0];
					  chainePtr = chaineTab;
					
					  //Affichage des equivalences
					  printf("Adresse chainPtr: %s, contenu chaineTab: %s\n", chainePtr, chaineTab);
					  printf("Adresse chainePtr: %x, adresse chaineTab: %x\n", chainePtr, chaineTab);
					  printf("Contenu chainPtr: %s, contenu chaineTab: %s\n", chainePtr, chaineTab);
					
					  for(i=0;i<TAILLE_TAB;i++)
						printf("%ld = %ld\n", *(intPtr+i), intTab[i]);
					}

Question

Quelle est l'équivalence tab[i][j] sous forme de pointeurs ?

Quelle est la différence de taille entre

sizeof(char*)

et

sizeof(long int*)

Les pointeurs pour les chaines de caractères

En fait toutes les entêtes de fonctions utilisant des chaines de caractère utilisent char*.

Mais attention il reste des différences:

//Exemple de difference:
					printf("Taille pointeur: %d, Taille tableau : %d\n", sizeof(intPtr), sizeof(intTab));
					//Output: Taille Pointeur: 4, Taille tableau: 160 (20*8, 8 taille d’un long long int)

int afficheChaine(const char *tab)
					{
					  while(*tab) //Equivalent à while(*tab != '\0')
						putchar(*(tab++));
					  puts("\n");
					  //*tab = 'a'; //Erreur à la compilation !
					}

Allocation dynamique

Exemple d'allocation dynamique

#include<stdlib.h>
					#include<stdio.h>
					int main(void) {
					  float *dynFloat = NULL;
					  char *buffer = NULL;
					  int taille;
					  printf("Entrer la taille desiree: "); scanf("%d", &taille);
					
					  //malloc et calloc retournent void*, il est donc nécéssaire de
					  //faire un cast dans le bon type du pointeur
					  dynFloat = malloc(taille*sizeof(float));
					  buffer = calloc(taille, sizeof(char));
					
					  //Erreur lors de l'allocation
					  if((dynFloat == NULL) || (buffer == NULL)) {
						printf("Erreur: impossible d'allouer la memoire necessaire.\n");
						free(buffer); free(dynFloat);//Ne fait rien si == NULL
						return 1;//ou exit(1)
					  }
					
					  *buffer = 'H'; *(buffer+1) = 'A', *(buffer+2) = 'L';
					  printf("Contenu buffer: %s\n", buffer); //Ok car mise à zero (calloc)
					  printf("Contenu float: %f\n", *(dynFloat+3)); //valeur indéfinie
					
					  //Libération de la mémoire
					  free(buffer); free(dynFloat);
					  return 0;
					}

Structures de données

Définition de nouveaux types

Il est possible de définir de nouveaux type de variable grâce au mot clé typedef.

Cela permet de:

• augmenter la lisibilité du code;
• garantir une opacité du point de vu de l’utilisateur (il n’a pas besoin de savoir ce qui ce cache derrière le type définit);
• changer le type d’une variable sans avoir à changer toutes les entêtes de fonctions.

typedef unsigned char bool;//definition d'un type booleen
					
					typedef int number; //peut etre facilement remplacé par un float
					number traiteLesDonnees(number x);//Fonction qui ne changera pas (à priori)
					
					// TYPES OPAQUES
					typedef /*something*/ time_t;//Definition officielle de time_t (time.h)
					//It is almost universally expected to be an integral value representing
					// the number of seconds elapsed since 00:00 hours, Jan 1, 1970 UTC.
					
					// Definition du type FILE utilisé (mais pas déclaré) dans stdio.h
					struct _IO_FILE;
					typedef struct _IO_FILE FILE;

Définition de structures

Une structure de donnée est une collection de données hétérogènes:

• chaque champ peut avoir un type différent;
• chaque champ à son propre espace mémoire réservé.

Déclaration d'une variable

struct {
					  int valueInt;
					  float valueFloat;
					  char valueChar;
					} maVariable;

Attention: le mot clef struct ne définit pas un type !

Question

Quel type de structures de données complexe les struct permettent de construire ?

Utilisation de structures (définitions)

Une structure est définie et appelée de la manière suivante:

//Déclaration de la structure
					struct personne {
					  char* nom;
					  char* prenom;
					  int age;
					};
					
					struct personne unePersonne; // une instance de la structure;

Pour plus de facilité on a souvent recours aux définitions de types:

typedef struct el { //el est necessaire pour faire les declaration de pointeurs
					  struct el *suivant;
					  void* contenu;
					} element_t;//A partir de cette définition on peu déclarer 'element_t unElement'
					
					typedef element_t* listeChainee;

Utilisation de structures (API personne)

struct personne createPersonne(const char* nom, const char* prenom, int age) {
					  int length;
					  struct personne pers;
					
					  length = strlen(nom) + 1;//+1 pour '\0'
					  pers.nom = calloc(length, sizeof(char));
					  pers.prenom = calloc(strlen(prenom) + 1, sizeof(char));
					  if((pers.nom == NULL) || (pers.prenom == NULL)) {
						printf("Erreur allocation mémoire\n");
						exit(1);
					  }
					  strcpy(pers.nom, nom);
					  strcpy(pers.prenom, prenom);
					  pers.age = age;
					  return pers;
					}
					
					void affichePersonne(struct personne pers) {
					  printf("Nom: %s, Prenom: %s, Age: %d\n", pers.nom, pers.prenom, pers.age);
					}

Utilisation de structures (API listes)

listeChainee initListeChaineeVide() {
					  return NULL;
					}
					
					void addListe(listeChainee* liste, void* contenu) {
					  //Creation d'un element et ajout dans la liste
					  element_t *unEl = (element_t*) malloc(sizeof(element_t));
					  unEl->contenu = contenu; //(*unEl).contenu se transforme en unEl->contenu
					  unEl->suivant = *liste;
					  *liste = unEl;
					}
					
					void* removeListe(listeChainee *liste) {
					  listeChainee tmp;
					  void* ret;
					
					  ret = (*liste)->contenu;
					  tmp = *liste;
					  *liste = tmp->suivant;
					  free(tmp); //Libération de la mémoire
					  return ret;
					}

Utilisation de structures (programme)

int main(void)
					{
						struct personne *ptPersonne;
						listeChainee maListe = initListeChaineeVide();
					
						//Une première personne ajoutée
						unePersonne = createPersonne("Rodepeter", "Jessica", 36);
						affichePersonne(unePersonne);
						addListe(&maListe, &unePersonne);
					
						//Une seconde personne ajoutée
						if((ptPersonne = malloc(sizeof(struct personne))) == NULL)
						{
							printf("Erreur mémoire\n");
							return 1;
						}
						*ptPersonne = createPersonne("Page", "Marc", 8);
						affichePersonne(*ptPersonne);
						addListe(&maListe, ptPersonne);
					
						//Recupère le contenu de la liste
						affichePersonne(*( (struct personne*) removeListe(&maListe)));
						affichePersonne(*( (struct personne*) removeListe(&maListe)));
						free(ptPersonne);
					
						return 0;
					}

Enumérations

Les énumérations permettent de créer des types:

• dont les valeurs sont discrètes, qualitative et éventuellement ordonnées;
• en fait ces valeurs sont représentées par des entiers.

Exemples de déclarations:

enum typeMedaille { bronze, argent, or };
					typedef enum { false,  } booleen;
					typedef enum { lundi = 1, mardi, mercredi, jeudi, vendredi, samedi, dimanche } jours;
					typedef enum { micro = 2, mineur = 4, leger = 5, modere = 6, major = 7, important = 9,
								   devastateur = 10} richter;

Exemples d'utilisations:

jours aujourdhui;
					aujourdhui = mardi;
					if(aujourdhui != mardi)
					  printf("Que faites-vous la ?\n");
					else
					  printf("Merci d'etre la.\n");

Enumérations

enum typeMedaille maMedaille = or;
					switch(maMedaille) //Séparer les different cas que peut prendre une variable
					{
					  case bronze:
						printf("Peux mieux faire !\n");
						break;//A ne pas oublier
					  case argent:
						printf("Pas mal !\n");
						break;
					  case or:
						printf("Le controle est par la...\n");
						break;
					  default:
						printf(“Erreur: type de medaille non connu\n");
					}

Attention les énumération ne sont PAS fortement typées:

//Toutes ces affectations sont autorisées !!!
					//Mais à éviter !
					int tremblementFukushima = 9;//Déclaré comme entier au lieux de richter
					richter tremblement = 3;//La valeur 3 n’est pas dans la liste
					booleen estValideMaisFaux = mardi; //mardi = 2 -> n’est pas dans la liste

Unions

Comme les structures, une union a plusieurs champs mais dans le même espace mémoire:

• l’adresse de chaque champs est la même;
• l’union a la taille du plus grand des champ.

Structures

typedef struct {
					  int valueInt;
					  float valueFloat;
					  char valueChar;
					} u;

Unions

typedef union {
					  int valueInt;
					  float valueFloat;
					  char valueChar;
					} s;

Unions

#include<stdio.h>
					#include<stdint.h>
					typedef union {
					  int16_t valueInt;
					  struct {
						unsigned char msb; //most significant byte
						unsigned char lsb; //least significant byte
					  } bytes;
					} convert;
					
					int main(void) {
					  convert value;
					  printf("Entrer un entier: ");
					  scanf("%d", &value);
					  printf("Valeur entree: %d\n", value.valueInt);
					  printf("Valeur entree (hexadecimal): %x\n", value);
					  printf("MSB: h%02x, LSB h%02x\n", value.bytes.lsb, value.bytes.msb);
					}

Organisation d'un programme

Modules

Un programme complexe est divisé en modules (.c + .h)

Cela permet notament de:

• créer une forme d'encapsulation qui facilite le deboguage et les mises à jour;
• réduire les temps de compilation en ne compilant que les modules modifiés;
• répartir le travail entre programmeurs;
• favoriser le partage de code (bibliothèques).

Compilation de modules

On peu utiliser un module en le compilant avec son programme principal:

Compilation de librairie

On peu utiliser un module en créant une librairie (statique dans cet exemple):

Lier une librairie

Pour utiliser la librairie il faut la lier:

Types opaques

#include"listeChainee.h"
					
					/*Déclaration dans le .c pour une
					utilisation privée */
					typedef struct el {
					  struct el *suivant;
					  void *contenu;
					} element_t;
					
					listeChainee initListeChaineeVide() {
					  return NULL;
					}

// Anciennement typedef element_t* listeChainee;
					typedef struct el* listeChainee;
					
					listeChainee initListeChaineeVide();
					void addListe(listeChainee* liste, void* contenu);
					void* removeListe(listeChainee *liste);

Fonctions static

Le mot clef static permet de:

• s’assurer que une fonction sera locale à un module (i.e. elle ne pourra pas être utilisée dans un autre module);
• Libérer le nom de cette fonction pour d’autres modules.

#include<stdio.h>
 
void show() { // PAS DE CONFLIT !
  printf("Main show\n");
}
 
void main() {
  show();
  interface();
}
#include<stdio.h>
 
void show() { // PAS DE CONFLIT !
  printf("Main show\n");
}
 
void main() {
  show();
  interface();
}

#include<stdio.h>
 
static void show() {  //PAS DE CONFLIT !
  printf("Interface show\n");
}
void interface() {
  show();
}
#include<stdio.h>
 
static void show() {  //PAS DE CONFLIT !
  printf("Interface show\n");
}
void interface() {
  show();
}

Attention le mot clef static est est aussi utilisé pour des variables mais il peu avoir un sens différent dans ce cas.

Exemple d'orgnanisation d'un programme

Makefiles

Complexité de compilation modulaire

Lorsque l’on a plusieurs modules qui dépendent les uns des autres il deviens difficile de savoir quel module il faut recompiler après une modification.

Création d'un makefile

Un makefile est un fichier texte qui contient des objectifs de compilation:

• chaque objectif représente (en général) un fichier .o ou le programme;
• chaque objectif est associé à:
  • une liste de dépendances (.o, .c, .h);
  • une commande à exécuter si une des dépendances à une date plus récente que l’objectif.

Exemple de Makefile

paint: main.o images.o gui.o graphics.o
						gcc main.o images.o gui.o graphics.o -o paint
					
					main.o: main.c images.h gui.h
						gcc -c main.c -o main.o
					
					images.o: images.c images.h graphics.h
						gcc -c images.c -o images.o
					
					gui.o: gui.c gui.h graphics.h
						gcc -c gui.c -o gui.o
					
					graphics.o: graphics.c graphics.h
						gcc -c graphics.c -o graphics.o

Utilisation d'un makefile

Pour compiler il suffit de taper:

$ make objectif

Pour compiler le premier objectif:

$ make

Variables

VARIABLE = value

$(VARIABLE) ou ${VARIABLE}

$ make VARIABLE=value objectif

VARIABLE ?= value

Amélioration d'un makefile (1)

CC = gcc
					OBJS = main.o images.o gui.o graphics.o
					CFLAGS = -g -Wall -c
					LFLAGS = -L /home/me/blas/openblas/lib -l openblas
					
					paint: $(OBJS)
						$(CC) $(OBJS) -o paint $(LFLAGS)
					
					main.o: main.c images.h gui.h
						$(CC) $(CFLAGS) paint.c -o main.o
					
					images.o: images.c images.h graphics.h
						$(CC) $(CFLAGS) images.c -o images.o
					
					gui.o: gui.c gui.h graphics.h
						$(CC) $(CFLAGS) gui.c -o gui.o
					
					graphics.o: graphics.c graphics.h
						$(CC) $(CFLAGS) graphics.c -o graphics.o

Branchements conditionels

Les branchements permettent de définir des variables ou des commandes différentes suivant une condition.

Par exemple:

libs_for_gcc = -lgnu
					normal_libs =
					
					foo: $(objects)
					ifeq ($(CC),gcc)
					   $(CC) -o foo $(objects) $(libs_for_gcc)
					else
					   $(CC) -o foo $(objects) $(normal_libs)
					endif

On peut aussi utiliser ifneq.

Amélioration d'un makefile (2)

CC = gcc
					OBJS = main.o images.o gui.o graphics.o
					CFLAGS = -g -Wall -c
					BLASLIB ?= openblas
					
					ifeq ($(BLASLIB), openblas)
						LFLAGS = -L /home/me/blas/openblas/lib -l openblas
					else ifeq ($(BLASLIB), cblas)
						LFLAGS = -L /home/me/blas/cblas/lib -l cblas
					else
						$(error unknown library $(BLASLIB))
					endif
					
					paint: $(OBJS)
						$(CC) $(OBJS) -o paint $(LFLAGS)
					
					...

Objectifs PHONY (bidon)

Certain objectifs ne sont pas associés à des fichiers

.PHONY = clean install   # pas obligatoire mais evite le test d'existence de fichiers
					
					clean:
						rm ./*.o ./paint
					
					install:
						cp ./paint /usr/local/bin

Questions

Quelles sont les actions usuelles pour compiler les sources d’un programme téléchargé sous Unix ?

Pourquoi la commande «clean» précédente peut être dangereuse si mal utilisée ?

Refaire un graph de compilation et le makefile à partir de l’exemple listechainee et personnes.

Directives de Precompilation

Include

Inclure les entêtes (.h) de fonctions des librairies ou des fichier C :

• pour les entêtes de librairies standard (emplacements prédéfinis):

  #include<stdlib.h>

• pour les entêtes utilisateur (même emplacement que le fichier courant puis emplacements prédéfinis):

  #include"listeChainee.h"

Macros

On peu définir des macros et constantes de la manière suivante:

#include<stdio.h>
					#include"precomp.h"
					
					#define USUAL 10; //Déjà vu
					#define WHY //on peut aussi declarer des define sans valeur
					
					//Défintion de macro:
					//Notez que ? et : sont utilisable dans le code
					//pour remplacer les if
					#define COMPUTE (INPUT / USUAL) //INPUT has to be defined
					#define MIN(a,b) (((a) < (b)) ? (a) : (b))
					
					int main()
					{
					  char string[] = STRING; //STRING doit etre defini lors de la compilation
					  printf("defined STRING: %s\n", string);
					  printf("defined VALUE: %d\n", INPUT); //INPUT doit être défini lors de la compilation
					  printf("Le plus petit nombre est: %d\n", MIN(INPUT, 5));
					}

Lors de la compilation:

$ gcc precomp.c -o precomp -D STRING="\"Je suis bien content\"" -D INPUT=5

Question

Y a-t-il des cas ou une macro ne sera pas dans un .h ?

Directives pré-définies

Des constantes sont prédéfinies par la plupart des compilateurs pour chaque fichier source:

• __DATE__ string indiquant le jour du dernier passage du pré-compilateur;
• __TIME__, string indiquant la date du dernier passage du pré-compilateur;

Utile pour la gestion d'erreurs:

• __LINE__, numéro de ligne du fichier;
• __FILE__, nom du fichier .

Utile pour compiler du code différent suivant la platforme:

• _WIN32, _WIN64 , __unix__, __APPLE__, __MACH__ définissent le type de système d’exploitation

Compilation conditionelle

La compilation conditionelle:

• Effectue une pré-compilation différente suivant les paramètres de pré-compilation;
• Compile un code différent suivant les paramètres de pré-compilation;

Utile pour:

• La compilation sur des plateformes différentes;
• L’inclusion infinie de .h;
• pour la création de constantes suivant les options de compilation;

#if TAILLES==0
					#define TAILLE_TAMPON 512
					#elif TAILLES==1
					#define TAILLE_TAMPON 1024
					#else
					#define TAILLE_TAMPON 2048
					#endif

#ifndef _win64
					//Quelque chose pour les platformes 64 bit windows
					#elif defined _win32
					//Quelque chose pour les platformes windows
					#else
					//Quelque chose pour les autres
					#endif

Compilation conditionelle

precomp.h

#ifndef _PRECOMP_H //Evite l’inclusion infinie
					#define _PRECOMP_H
					
					//Define a constant with the system name
					#ifdef __unix__
					#define SYS "Unix"
					#elif defined _WIN32
					#define SYS "Windows"
					#elif defined __APPLE__
					#define SYS "Mac"
					#else
					#define SYS "Unknown"
					#endif
					
					/********************* User interface************************/
					
					/*************************************************************
					Détermine quel est le caractère de séparation des répertoires
					qui correspond au système d'exploitation sur lequel le programme
					as été compilé.
					IN: vide
					OUT: retourne un caractère représentant le séparateur de dossiers.
					retourne -1 si il n'as pas pu être identifié (système non identifié)
					**************************************************************/
					char getCharSep();
					
					#endif //#def _PRECOMP_H

Compilation conditionelle

precomp.c

/*************************************************************
					Détermine quel est le caractère de séparation des répertoires
					qui correspond au système d'exploitation sur lequel le programme
					as été compilé.
					IN: vide
					OUT: retourne un caractère représentant le séparateur de dossiers.
					retourne -1 si il n'as pas pu être identifié (système non identifié)
					**************************************************************/
					char getCharSep()
					{
					#ifdef __unix__
					  return '/';
					#elif defined _WIN32
					  return '\\';
					#elif defined __APPLE__
					  return '/';
					#else
					  return -1;
					#endif
					}