• Expressions et opérateurs (suite)
• Déclaration (suite)
• Pré-processeur
• Entrées / sorties (suite)

C-VI  1

1. Conversion de type
2. Opérateur de portée

C-VI  2

• Explicite, par appel de fonction fait lors de la compilation :
  • (type) áexpressionñ (en C et C++)
  • ou type (áexpressionñ) (similaire à un appel de fonction. En C++ uniquement)

  int x, y;

  // double sqrt(double)

  y = (int) (3*sqrt((double)x)); // en C et C++

  y = int (3*sqrt(double(x))); // en C++

• Implicite pour les opérateurs :

  Règle	Si une opérande est   :	l'autre opérande
  		est convertie en :
  1.	long double	long double
  2.	double	double
  3.	float	float
  4.	long int	long int
  5.	promotion en entier

C-VI  3

• En C++, utilisation possible de l'opérateur de portée :: pour accéder à des noms cachés.

C-VI  4

1. Effets des déclarations
2. Variables externes

C-VI  5

Visibilité ou portée (anglais : scope):

 
détermine les parties du programme capables d'accéder à un identificateur (variable ou fonction);

Initialisation :

 
détermine le contenu initial (pour les variables).

Durée de vie (anglais : extent):

 
détermine à quel moment la mémoire correspondante est allouée et est libérée;

C-VI  6

Fonction

 
° visibilité : de la déclaration à la fin du fichier; Accessible dans d'autres modules avec extern SAUF si déclarée en static;
° durée de vie : programme.

Variable dans un bloc

 
° visibilité : de la déclaration à la fin du bloc;
° initialisation : aucune par défaut;
° durée de vie : bloc (auto).

Variable globale

 
° visibilité : de la déclaration à la fin du fichier; Accessible dans d'autres modules avec extern SAUF si déclarée en static;
° initialisation : 0 par défaut (MAIS ne pas compter dessus) ;
° durée de vie : programme.

C-VI  7

• Visibilité: selon la déclaration (locale ou globale);
• Mot clé: extern
• Durée de vie : le programme.

C-VI  8

• Fichier a.cc

  int mavaleur;

  int mavaleurinit = 0;

  static int mavaleurstatique=3;

  static int g(void) { ... }

  void f(int a) { ... g(); ... }

• Fichier utilisea.cc

  extern void f(int);

  int main(void) {

  ...

  extern int mavaleur; // OK. Val. initiale ?

  extern int mavaleurinit; // OK

  g(); // Erreur compilation

  f(3); // OK

  f(mavaleur); // OK

  f(mavaleurstatique); // Erreur compil.

  }

C-VI  9

• Utilisation explicite (cpp) ou implicite (à chaque compilation),
• Utile pour :
  • les remplacements textuels,
    --> constantes, macros,
  • l'inclusion textuelle de fichiers,
    --> utilisation des fichiers d'en-tête,
  • la compilation conditionnelle,
• Les directives destinées à cpp sont des lignes COMMENCANT par un "#".
  Attention : pas de ``;'' (source d'erreurs difficiles à détecter !!!).

C-VI  10

#define  TRUE    1
#define  FALSE   0

#define  PI      3.141592

C-VI  11

#define  carre(x)      ((x)*(x))

#define  moyenne(a,b)  (((a)+(b))/2)

#define  max(a,b)      (((a)>(b))?(a):(b))
   .
   .
   .
int i, j, k=10;

i=carre(k);
j=carre(k++);

C-VI  12

#if DEBUG
  /* code inclus ssi DEBUG est != 0 */
  fprintf(stderr, ...);
#endif


#ifdef IBM
  ...  /* code spécifique à l'IBM */
#else
  ...  /* cas général */
#endif


#ifndef pile_h
#define pile_h
  .
  .     /* Placer ici le contenu de pile.h */
  .
#endif

C-VI  13

C-VI  14

C-VI  15

1. E/S sur fichiers en C.

C-VI  16

• Déclaration d'un pointeur sur fichier :
  FILE *pf;
• Ouverture d'un fichier :
  pf = fopen(nom_fichier, mode);
  Avec mode pouvant prendre plusieurs valeurs dont :
  • la lecture (read) : r
  • l'écriture (write) : w
  • l'ajout en fin de fichier (append) : a
• Fermeture d'un fichier :
  fclose(pf);

C-VI  17

• Test de fin de fichier :
  feof(pf);
• Lecture/écriture d'un caractère :
  fgetc(pf);
  fputc(c, pf);
• Lecture/écriture d'une chaîne :
  fgets(s, n, pf);
  fputs(s, pf);
• Lecture et écriture formatée :
  fprintf(pf, format, valeurs);
  fscanf(pf, format, adresses);
• Synchronisation (vide le tampon associé) :
  fflush(pf);
• ...