/*************************************************************************
                           IntervalSet  -  description
                             -------------------
    début                : 17 oct. 2011
    copyright            : (C) 2011 par nreynolds
*************************************************************************/

//---------- Réalisation de la classe <IntervalSet> (fichier IntervalSet.cpp) --

//---------------------------------------------------------------- INCLUDE

//-------------------------------------------------------- Include systéme
using namespace std;
#include <iostream>

//------------------------------------------------------ Include personnel
#include "IntervalSet.h"

//------------------------------------------------------------- Constantes

//---------------------------------------------------- Variables de classe

//----------------------------------------------------------- Types privés


//----------------------------------------------------------------- PUBLIC
//-------------------------------------------------------- Fonctions amies

//----------------------------------------------------- Méthodes publiques
// type IntervalSet::Méthode ( liste de paramétres )
// Algorithme :
//
//{
//} //----- Fin de Méthode


//------------------------------------------------- Surcharge d'opérateurs
/*IntervalSet & IntervalSet::operator = ( const IntervalSet & unIntervalSet )
// Algorithme :
//
{

} //----- Fin de operator =*/


//-------------------------------------------- Constructeurs - destructeur
IntervalSet::IntervalSet ( const IntervalSet & unIntervalSet )
// Algorithme :
//
{
#ifdef MAP
    cout << "Appel au constructeur de copie de <IntervalSet>" << endl;
#endif
} //----- Fin de IntervalSet (constructeur de copie)


IntervalSet::IntervalSet ( )
// Algorithme :
//
{
#ifdef MAP
    cout << "Appel au constructeur de <IntervalSet>" << endl;

    premierIntervalle = new intervalle;
    premierIntervalle.borneInf = NULL;
    premierIntervalle.borneSup = NULL;
    premierIntervalle.prochainIntervalle = NULL;
#endif
} //----- Fin de IntervalSet


IntervalSet::~IntervalSet ( )
// Algorithme :
//
{
#ifdef MAP
    cout << "Appel au destructeur de <IntervalSet>" << endl;



	intervalle intervalleActif;
	intervalle intervalleASupprimer;
	intervalleActif = *premierIntervalle;

	//Parcourir la liste chaînée en supprimant au fur et à mesure
	while (intervalleActif.prochainIntervalle != NULL)
	{
		intervalleASupprimer = intervalleActif;
		intervalleActif = *intervalleActif.prochainIntervalle;

		delete intervalleASupprimer;
	}

	delete intervalleActif;




#endif
} //----- Fin de ~IntervalSet

void IntervalSet::Ajouter ( int inf, int sup )
// Algorithme :
//

{
	//Parcourir la liste chaînée pour trouver le dernier intervalle

	intervalle intervalleActif;
	intervalleActif = *premierIntervalle;

	while (intervalleActif.prochainIntervalle != NULL)
	{
		intervalleActif = *intervalleActif.prochainIntervalle;
	}

	//Rajouter le dernier intervalle
	intervalleActif.prochainIntervalle = new intervalle;

	intervalleActif = *intervalleActif.prochainIntervalle;
	intervalleActif.borneInf = inf;
	intervalleActif.borneSup = sup;
	intervalleActif.prochainIntervalle= NULL;

} //----- Fin de NouvelIntervalle





int IntervalSet::NombreElements ( )
// Algorithme :
//

{
	//Parcourir la liste chaînée en incrémentant
	intervalle intervalleActif = *premierIntervalle;
	int NombreElements = 1;


	while (intervalleActif.prochainIntervalle != NULL)
	{
		intervalleActif = *intervalleActif.prochainIntervalle;
		NombreElements++;
	}

	return NombreElements;
} //----- Fin de NombreElements





//------------------------------------------------------------------ PRIVE

//----------------------------------------------------- Méthodes protégées

//------------------------------------------------------- Méthodes privées



//------------------------------------------------------------------------
//------------------------------------------------------------------------
//------------------------------------------------------------------------


#include <iostream>
using namespace std;

int main()
{

	cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!

	IntervalSet Lolilol = *new IntervalSet;
	Lolilol.Ajouter(2,3);
	Lolilol.Ajouter(8,9);
	Lolilol.Ajouter(10,11);

	cout << Lolilol.NombreElements() << endl;

	return 0;
}





2eme :

/*************************************************************************
                           IntervalSet  -  description
                             -------------------
    début                : 17 oct. 2011
    copyright            : (C) 2011 par nreynolds
*************************************************************************/

//---------- Interface de la classe <IntervalSet> (fichier IntervalSet.h) ------
using namespace std;
#if ! defined ( IntervalSet_H )
#define IntervalSet_H

//--------------------------------------------------- Interfaces utilisées

//------------------------------------------------------------- Constantes

//------------------------------------------------------------------ Types

//------------------------------------------------------------------------
// R�le de la classe <IntervalSet>
//
//
//------------------------------------------------------------------------

class IntervalSet
{
//----------------------------------------------------------------- PUBLIC

public:
//----------------------------------------------------- Méthodes publiques
    // type Méthode ( liste de paramètres );
    // Mode d'emploi :
    //
    // Contrat :
    //


//------------------------------------------------- Surcharge d'opérateurs
    IntervalSet & operator = ( const IntervalSet & unIntervalSet );
    // Mode d'emploi :
    //
    // Contrat :
    //


//-------------------------------------------- Constructeurs - destructeur
    IntervalSet ( const IntervalSet & unIntervalSet );
    // Mode d'emploi (constructeur de copie) :
    //
    // Contrat :
    //

    IntervalSet ( );
    // Mode d'emploi :Crée un ensemble d’intervalles.
    //Et renvoie le numéro de l’ensemble L’ensemble ainsi créé est l’ensemble n°: k
    //(k étant un incrémenté à chaque création d’un nouvel intervalle)
    //
    // Contrat :
    //

    virtual ~IntervalSet ( );
    // Mode d'emploi :
    //
    // Contrat :
    //

    void Ajouter ( int inf, int sup );

    int NombreElements ( );

//------------------------------------------------------------------ PRIVE

protected:
//----------------------------------------------------- Méthodes protégées

private:
//------------------------------------------------------- Méthodes privées

protected:
//----------------------------------------------------- Attributs protégés

private:
//------------------------------------------------------- Attributs privés

//---------------------------------------------------------- Classes amies

//-------------------------------------------------------- Classes privées

//----------------------------------------------------------- Types privés
    typedef struct interval
    {
    	int borneInf , borneSup;

    	struct interval *prochainIntervalle;
    }intervalle;


    intervalle *premierIntervalle;


};

//----------------------------------------- Types dépendants de <IntervalSet>

#endif // IntervalSet_H