//  Objectif : Implantation de la classe Date

#include <iostream>
#include "Date.h"

using namespace std;

// Constructeurs : la zone mémoire nécessaire pour représenter
// l'objet est reservée par le compilateur (ou le système) avant
// l'appel du constructeur.  Ainsi, le rôle du constructeur est
// seulement d'initialiser l'état (les attributs) de l'objet.

Date :: Date(short jj, short mm, int aa)
: _jour(jj), _mois(mm), _annee(aa)
{}


// Destructeur : Il est appelé automatiquement par le compilateur
// avant de libérer la zone mémoire utilisée par un objet.  Le
// destructeur sert au programmeur pour libérer les ressources
// qu'il a allouées explicitement lors de la << construction >>
// de l'objet et qui ne sont donc pas restituées automatiquement
// (mémoire dynamique, fermeture de fichiers, etc.).

Date :: ~Date()
{
    // Rien à faire dans la cas présent !
}

short Date::jour() const
{
    return _jour;
}

short Date::mois() const
{
    return _mois;
}

int Date::annee() const
{
    return _annee;
}

void Date :: set(short jj, short mm, int aa) 
{
    _jour = jj;
    _mois = mm;
    _annee = aa;
}

void Date :: afficher(std::ostream &out) const
{
    out << jour() << "/" << mois() << "/" << annee() << endl;
}


// Implantation de lt fonction membre de la classe
bool Date :: lt(const Date &d2) const
{
	bool resultat;

	if (_annee != d2.annee())
		resultat = _annee < d2.annee();
	else if (_mois != d2.mois())
		resultat = _mois < d2.mois();
	else
		resultat = _jour < d2.jour();

	return resultat;
}

// Implantation de lt fonction de classe
// Remarque : le mot-clé static n'apparaît que dans le .h.
bool Date :: lt(const Date & d1, const Date &d2)
{
	return d1.lt(d2);
}

// Implantation de lt fonction hors de la classe
// Notons qu'il n'y a donc pas de préfixe Date ::.
bool lt(const Date & d1, const Date &d2)
{
	return d1.lt(d2);
}

// autres opérations de comparaison

bool Date :: ge(const Date &d2) const
{
	return ! this->lt(d2);
}

bool Date :: gt(const Date &d2) const
{
	return d2.lt(*this);
}

bool Date :: le(const Date &d2) const
{
	return d2.ge(*this);
}

bool Date :: eq(const Date &d2) const
{
	return this->le(d2) && this->ge(d2);
}

bool Date :: neq(const Date &d2) const
{
	return !this->eq(d2);
}



bool Date ::operator<(const Date & d2) const
{
	return lt(d2);
}
bool Date ::operator>(const Date & d2) const
{
	return gt(d2);
}
bool Date ::operator<=(const Date & d2) const
{
	return le(d2);
}
bool Date ::operator>=(const Date & d2) const
{
	return ge(d2);
}
bool Date ::operator==(const Date & d2) const
{
	return eq(d2);
}
bool Date ::operator!=(const Date & d2) const
{
	return neq(d2);
}

ostream& operator<<(ostream & out, const Date & d2)
{
	out << "( " << d2.
}