/*******************************************************************
  Implantation du T.A.D. carre

   Analyse

   Un carre est connu par son cote
   Les formules necessaires sont:
      perimetre = 4*cote
      surface = cote^2
*******************************************************************/
#include <iostream>
using namespace std;

class Carre
{
	float cote ;
public:
	Carre() ;
	Carre(float) ;
	void lecture();
        void lecture(istream&);
	void imprime() ;
        void ecrire(ostream&);
	float perimetre() ;
	float surface() ;
} ;


/*****************************************************************

   Methodes pour le type Carre
			 
*****************************************************************/
/*---------------------------------------------------------------
   Contructeurs
---------------------------------------------------------------*/
Carre::Carre()
{
	cote = 0 ;
}
Carre::Carre(float valeur_cote)
{
	cote = valeur_cote ;
}

/*---------------------------------------------------------------
   Lecture
---------------------------------------------------------------*/
// De l'entree standard (clavier)
void Carre::lecture()
{
	cin >> cote ;
}
// D'un stream quelconque (clavier, fichier, ...)
void Carre::lecture(istream& in)
{
	in >> cote ;
}
/*---------------------------------------------------------------
   Methode pour le calcul...
---------------------------------------------------------------*/

float Carre::perimetre()
{
	return 4 * cote ;
}

float Carre::surface()
{
	return cote * cote ;
}
/*---------------------------------------------------------------
   Ecriture
---------------------------------------------------------------*/
// Sur la sortie standard (ecran)

void Carre::imprime()
{
	cout << cote ;
}
// Sur un stream quelconque (ecran, fichier, ...)
void Carre::ecrire(ostream& out)
{
	out << cote ;
}
/*---------------------------------------------------------------
   Redefinition de >> (pour la lecture)
---------------------------------------------------------------*/
istream& operator>>(istream& is, Carre& de) {
  
  de.lecture(is);
  return is;
}
/*---------------------------------------------------------------
   Redefinition de << (pour l'ecriture)
---------------------------------------------------------------*/

ostream& operator<<(ostream& os, Carre de) {
 
 de.ecrire(os);
 return os;
}