[C++] Utilisation <clocale> avec cout

"pour les flux type cout ou 'fstream'. "

Nous traitons ici, la surcharge de l’opérateur ‘<<’, celui-ci étant extrêmement lié à l’instruction « cout ». Nous avons eu recours à la documentation et à l’internet pour cerner le partage d’accès à la données par l’entremise de la librairie <ostream>. Bien que cette notion soit nouvelle, nous avons établie qu’une syntaxe du style :

// serieEntiers surcharge de l'operator  << 
// -> partage avec cout membre de ostream
friend ostream &operator<< (ostream & , const serieEntiers & );
	

pouvait nous permettre de capturer la série au complet dans ce que nous appellerons le flux de données défini par le partage de la classe « ostream ».

Nous soulignons ici, qu’en plus d’utiliser la surcharge de l’opérateur, nous nous associons avec un élément de la librairie, c'est-à-dire comme parrainé, encadré par la classe de la librairie « ostream », donc un plus grande sécurité d’accès à la donné.

ostream &operator<< (ostream &flux, const serieEntiers &s)
 {
   int j=0,k=0;

  flux << "\n\n\n     {";
  //lupin

  cout << endl;
  while ( k < tailleMax )
    {
        cout << "     ";
        while ( j < ( tailleMax / 10 ) )	// Description de la ligne
          {
              if ( s.tableauEntier[k] < 10 )
               {
                  if ( s.tableauEntier[k] == 1 ) flux << " " << k << " ";
                  else flux << "  ";
//	flux << s.tableauEntier[k] << " " ; // Ligne de déboggage
                  j++;
                  k++;
               }
             else
              {
                  if ( s.tableauEntier[k] == 1 ) flux << k << " ";
                  else flux << "  ";
//	flux << s.tableauEntier[k] << " " ; // Ligne de déboggage
                  j++;
                  k++;
              }
         };
       j = 0;	
      // Ligne suivante
      cout << endl;
  };
  flux << "     }\n\n\n";

//lupin
  return flux;
};

#include <iostream.h>
#include <iomanip.h>

int main()
{
   double x = 100.453627;

   cout << setiosflags( ios::fixed | ios::showpoint );

   for ( int loop = 0; loop <= 5; ++loop )

       cout << setprecision( loop ) 
			<< "Arrondi \205 " << loop 
            << " symbole(s) qui donne " << x << endl;

   return 0;
}


// setprecision défini la largeur de l'arrondi

// Arondi à 0 symbole(s) qui donne 100.
// Arondi à 0 symbole(s) qui donne 100.5
// Arondi à 0 symbole(s) qui donne 100.45
// Arondi à 0 symbole(s) qui donne 100.454
// Arondi à 0 symbole(s) qui donne 100.4536
// Arondi à 0 symbole(s) qui donne 100.45363

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
   double x = 100.453627;

   cout << (static_cast<int>(x))
            << ',' 
            << setprecision(0) 
            << static_cast<int>((x - (static_cast<int>(x)))*1000) 
            << endl;

   return 0;
}

//**********************************************************
// Fichier CaracFr.H (Lupin)
//
// Déclaration de la classe (modèle) CaracFranc
//
// Directives de précompilation qui empêchent de multiples
// inclusion du fichier d'en-tête

#ifndef CaracFranc_H
#define CaracFranc_H

#include <iostream>
#include <iomanip>

using std::ostream;
using std::cout;
using std::endl;
using std::setprecision;

const int tailleMax = 100;


// Définition du type de données abstrait CaracFranc
// LuPin Type : Type standard (structure) + 
//              Type membres fonctions (méthode et propriété)

class CaracFranc
{
	// membre internes et publics ( les fonctions membres )
	public:
		// Constructeur par défault (initialisation)
		CaracFranc();
		// Constructeur #2
		CaracFranc(  double );

		// serieEntiers surcharge de l'operator  <<
		// -> partage avec cout membre de ostream
		friend ostream &operator<< (ostream & , const CaracFranc & );

		// membre internes ( les données :-) )
	private:
		// Structure Type Tableau d'entiers prédéfini
		double maVariable;
};

CaracFranc::CaracFranc()
// Initialisation de la variable = 0
{
	maVariable=0;
	cout << "Premier constructeur en action ! ->" << endl;
};


CaracFranc::CaracFranc( double MaVar )
// Initialisation de la variable = 0
{
	maVariable=MaVar;
	cout << "Constructeur #2 en action ! ->" << endl;
};

ostream &operator<< (ostream &flux , const CaracFranc &Ptr)
{
//lupin
	double UneVarDbl = Ptr.maVariable;
    flux << (static_cast<int>(UneVarDbl)) 
	     << ',' 
		 << setprecision(0) 
		 << static_cast<int>((UneVarDbl - (static_cast<int>(UneVarDbl)))*1000);
//lupin
  return flux;
};

#endif
// Fin de fichier (Classe définie :-))

//**********************************************************************************
// Fichier CaracFr.cpp (Lupin)
//
// Démonstration de la classe

#include "CaracFr.h"

using std::cout;

void main (void)
{
	CaracFranc x,y(12.234),z(345.78);

	cout << "Ouverture du Programme" << endl;
	cout << x << endl  << y << endl  << z << endl;
	cout << "Fermeture du Programme" << endl;
};

//**********************************************************
// Fichier CaracFr.H
//
// Déclaration de la classe (modèle) CaracFranc
//
// Les fonctions membres sont définies dans CaracFranc.cpp
//
// Directives de précompilation qui empêchent de multiples
// inclusion du fichier d'en-tête

#ifndef CaracFranc_H
#define CaracFranc_H

#include <iostream>
#include <iomanip>

using std::ostream;
using std::cout;
using std::endl;
using std::ios;
using std::setiosflags;
using std::setprecision;

const int tailleMax = 100;


// Définition du type de données abstrait CaracFranc
// LuPin Type : Type standard (structure) + 
//              Type membres fonctions (méthode et propriété)

class CaracFranc
{
	// membre internes et publics ( les fonctions membres )
	public:
		// Constructeur par défault (initialisation)
		CaracFranc();
		// Constructeur #2
		CaracFranc( double [] );

		// serieEntiers surcharge de l'operator  <<
		// -> partage avec cout membre de ostream
		friend ostream &operator<< (ostream & , const CaracFranc & );

		// membre internes ( les données :-) )
	private:
		// Structure Type Tableau d'entiers prédéfini
		double maVariable[tailleMax];
};

CaracFranc::CaracFranc()
// Initialisation de la variable = 0
{
	memset(maVariable,0,sizeof(double)*tailleMax);
	cout << "Premier constructeur en action ! ->" << endl;
};


CaracFranc::CaracFranc( double copie[] )
{
	for ( int i = 0 ; i < tailleMax ; i++ )
	{
		maVariable[i] = copie[i];
	};
	cout << "Constructeur #2 en action ! ->" << endl;
};

ostream &operator<< (ostream &flux , const CaracFranc &Ptr)
{
//lupin

	for ( int j = 0 ; j < (tailleMax/5) ; j++ )
	{
		for ( int k = 0 ; k < (tailleMax/20) ; k++ )
		{
			double UneVarDbl = Ptr.maVariable[j*k];
			flux << (static_cast<int>(UneVarDbl)) << ',' 
				 << setiosflags ( ios::fixed | ios::showpoint ) << setprecision(0) 
				 << static_cast<int>((UneVarDbl - (static_cast<int>(UneVarDbl)))*1000);
			if ( k != ((tailleMax/20)-1) ) { flux << " - "; };
		 
		}
		flux << endl;
	}
	flux << endl;
//lupin
  return flux;
};

#endif
// Fin de fichier (Classe définie :-))

//***************************************************
// Fichier CaracFr.cpp
//
// Démonstration de la classe

#include "CaracFr.h"

using std::cout;

void main (void)
{
	double Boite[tailleMax];
	CaracFranc x;

	cout << "Ouverture du Programme" << endl;
	for ( int a = 0 ; a < tailleMax ; a++ )
	{
		Boite[a] = a * 3.14159;
	};

	CaracFranc y(Boite);

	cout << x << y ;
	cout << "Fermeture du Programme" << endl;
};

1,2 3 faux

class caracfranc
{
	// membres internes, protégés et  publics ( les fonctions membres )
	public:
		// Constructeur par défault (initialisation)
		caracfranc();
		// Constructeur #2
		caracfranc( double );

        inseredonnee( double );

		// caracfranc surcharge de l'operator  <<
		// -> partage avec cout membre de ostream
		friend ostream &operator<< (ostream & , const caracfranc & );

		// membres internes ( les données :-) )
	private:
		// Structure de Type "double" prédéfini
		double mavariable;
};

caracfranc::caracfranc()
// Initialisation de la variable = 0
{
	mavariable = 0;
	cout << "Premier constructeur en action ! ->" << endl;
};


caracfranc::caracfranc( double copie )
{
	mavariable = copie;
	cout << "Constructeur #2 en action ! ->" << endl;
};

caracfranc::inseredonnee( double donnee ) { mavariable = donnee; };

ostream &operator<< (ostream &flux , const caracfranc &Ptr)
{
//lupin

    double unevardbl = Ptr.mavariable;
    
    flux << (static_cast<int>(unevardbl)) << ',' 
            << setiosflags ( ios::fixed | ios::showpoint ) << setprecision(0) 
            << static_cast<int>((unevardbl - (static_cast<int>(unevardbl)))*1000);
//lupin
     return flux;
};