// initialiser.cpp    Syntaxe d'initialisations de constantes: <xmp>
// (auteur: R.Astier)
//
// Ici les initialisations sont écrites dans la même instruction
// que la déclaration de la variable. Ces exemples sont présentés car
// la syntaxe n'est pas toujours facile à mémoriser, surtout pour
// initialiser un tableau ou un tableau d'agrégats ...
//
// Initialisations de:
//    1. caractère, tableau de caractères (chaîne) et tableau
//          de chaînes
//    2. tableaux numériques à une ou deux dimensions
//    3. agrégats style C des années 1970, et tableau d'agrégats 
//    4. agrégats style C++ des années 1990, et tableau d'agrégats
//    5. objet et tableau d'objets; déclaration d'un tableau d'objets
//    6. initialisation de constantes statiques d'une classe
//    7. constantes définies dans un agrégat-1990 ou une classe
// g++ -o t initialiser.cpp


// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
#include <iostream.h>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +

// Exemple d'agrégat, style C des années 1970
typedef struct {
  double val;
  char * nom;
  } A;

// Exemple d'agrégat, style C++ des années 1990
struct AA {
  double val;
  char * nom;
  //    7.a constantes définies dans un agrégat
  enum exemple { MAX_UB=255, MAX_UI=0xFFFF};
  };

// Exemple de classe
class C {
public:
  // Le constructeur ci-dessous est appelé lors des déclarations:
  //    C logE=C(0.43429448,"log(e)");
  //    C TC[]={C(2.236068,"racine(5)"),C(65536),logE};
  C(double d,char *n="rien"): val(d),nom(n){}

  // Un constructeur sans paramètre est indispensable pour
  // créer un tableau non initialisé; exemple:   C tabC[5];
  C(): val(0),nom(""){}

  // Des champs standards
  double val;
  char * nom;

  // Des champs statiques, initialisés en dehors de la classe
  static const double td[];
  static const unsigned int ntd;
  static const char * tc[];
  static const unsigned int ntc;

  //    7.b constantes définies dans une classe
  enum exemple { MAX_UB=255, MAX_UI=0xFFFF};
  };

// 6. initialisation de constantes statiques d'une classe
//    Les déclarations ci-dessous ne doivent être visibles qu'une seule
//    fois lors d'une compilation; d'où la nécessité de les protéger
//    si elles figurent dans un fichier d'entête inclus par plusieurs
//    fichiers source
#ifndef INIT_TD
#define INIT_TD
const double C::td[]={1.1,2.2,3.3,4.4};
const unsigned int C::ntd=sizeof(td)/sizeof(td[0]);
const char * C::tc[]={"abc","def"};
const unsigned int C::ntc=sizeof(tc)/sizeof(tc[0]);
#endif


// - - -  D é c l r a t i o n s    et    u t i l i s a t i o n s - - - +
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
int  main( int nm, char *mots[]) {
// variable simple
// 1. caractère, tableau de caractères ou chaîne et tableau de chaînes
const char c='\n';
const char extension[]=".cpp";
const char *jours[]={"Lu","Ma","Me","Je","Ve","SA","DI"};
//    nombre de chaînes du tableau ci-dessus
const unsigned int nJours=sizeof(jours)/sizeof(jours[0]);

// 2. Tableaux numériques à une ou deux dimensions
//    à une dimension
const int njm[]={31,28,31,30,31,30,31,31,30,31,30,31};
//    à deux dimensions: il est indispensable d'indiquer la deuxième
//    dimension; le nombre de lignes est trouvé par le compilateur
const int mag[][10]={ { 16,  3,  2, 13},
                      {  5, 10, 11,  8},
                      {  9,  6,  7, 12},
                      {  4, 15, 14,  1}};
//    le nombre de colonnes effectivement initialisées n'est pas détecté
const unsigned int ncmag=4;

// 3. agrégats style C des années 1970, et tableau d'agrégats 
const A pi={3.14,"pi"};
// const A ta[]={{1.4142136,"racine(2)"},{2.718,"e"},pi};
const A ta[]={{1.4142136,"racine(2)"},{2.718,"e"}};

// 4. agrégats style C++ des années 1990, et tableau d'agrégats 
const AA PI={3.1415927,"PI"};
// const AA TA[]={{1.7320508,"racine(3)"},{2.7182818,"e"},PI};
const AA TA[]={{1.7320508,"racine(3)"},{2.7182818,"e"}};

// 5. objet et tableau d'objets; déclaration d'un tableau d'objets
const C logE=C(0.43429448,"log(e)");
const C TC[]={C(2.236068,"racine(5)"),C(65536),logE};
C tabC[5];

// Ci-après, des utilisations des variables déclarées; on peut constater
// pour les variables tableau, que le nombre d'éléments du tableau
// définis à l'initialisation peut quelquefois être trouvé par le
// compilateur.
unsigned int i,j; int s;
cout<<extension<<c;
for(i=0; i<nJours; i++)cout<<jours[i]<<' ';
cout<<endl;
for(i=0,s=0; i<sizeof(njm)/sizeof(njm[0]); i++) s+=njm[i];
cout<<"nb.total:"<<s<<endl;

for(i=0; i<sizeof(mag)/sizeof(mag[0]); i++) {
   for(j=0; j<ncmag; j++) {cout.width(4); cout<<mag[i][j];}
   cout<<endl;
   }

cout.precision(8);

cout<<"\nAgrégat, années 1970"<<endl;
cout<<pi.nom<<"="<<pi.val<<endl;
for(i=0; i<sizeof(ta)/sizeof(ta[0]); i++)
   cout<<ta[i].nom<<"="<<ta[i].val<<"   ";
cout<<endl;

cout<<"\nAgrégat, années 1990"<<endl;
cout<<PI.nom<<"="<<PI.val<<endl;
for(i=0; i<sizeof(TA)/sizeof(TA[0]); i++)
   cout<<TA[i].nom<<"="<<TA[i].val<<"   ";
cout<<endl;
cout<<"AA::MAX_UB="<<AA::MAX_UB<<"   AA::MAX_UI="<<AA::MAX_UI<<endl;


cout<<"\nConstantes définies dans une classe"<<endl;
cout<<logE.nom<<"="<<logE.val<<endl;
for(i=0; i<sizeof(TC)/sizeof(TC[0]); i++)
   cout<<TC[i].nom<<"="<<TC[i].val<<"   ";
cout<<endl;
for(i=0; i<C::ntd; i++) cout<<C::td[i]<<"  ";
cout<<endl;
for(i=0; i<C::ntc; i++) cout<<C::tc[i]<<"  ";
cout<<endl;
for(i=0; i<sizeof(tabC)/sizeof(tabC[0]); i++)
   cout<<i<<":{"<<tabC[i].val<<","<<tabC[i].val<<"}   ";
cout<<endl;
cout<<"C::MAX_UB="<<C::MAX_UB<<"   C::MAX_UI="<<C::MAX_UI<<endl;

// Voici comment détourner l'attention du compilateur si le programmeur
// veut modifier un élément déclaré avec l'attribut  const  !!!
((int&) mag[0][0])=-1;
*((int* ) &mag[0][0])=-1;

cout<<"\n> > >"; cin.getline( new char [80],80);
return 0;
}
//fin initialisation.cpp   </xmp>