TABLEAU 3D GÉNÉRIQUE

/////////////////////////////////////////////////////////////////////////////////////////////////
//
// tab3D.h
//
// Description
//      Classe permettant de faire de créer et gérer des tableaux 3D.
//
/////////////////////////////////////////////////////////////////////////////////////////////////



#ifndef TAB3D_H
#define TAB3D_H



/////////////////////////////////////////// CLASSE //////////////////////////////////////////////
template<class T>
class Tableau3D
{
public :
	// Constructeur/Destructeur
	Tableau3D();
	Tableau3D(int _nx, int _ny, int _nz);
	~Tableau3D();

	// Gestion de tableaux 3D
	bool Create (int _nx, int _ny, int _nz);	// Création de tableaux 3D
	void Delete ();					// Suppression de tableaux 3D
	bool Existing ();				// Existence du tableau ?
	void Initialize (T val);			// Initialisation

	// Présence dans le tableau
	bool InTable (int _nx, int _ny, int _nz );	// La case est-elle dans le tableau ?
	bool InTableX (int _nx);			// La ligne x est-elle dans le tableau ?
	bool InTableY (int _ny);			// La ligne y est-elle dans le tableau ?
	bool InTableZ (int _nz);			// La ligne z est-elle dans le tableau ?

	// Taille en mémoire du tableau
	unsigned long Memoire ();

	// Variable de sortie
	T& Extract(int _nx, int _ny, int _nz );		// Extraire la valeur après vérif. d'existence
	T ***tab3D;

private:
	T *adr1;
	T **adr2;
	int nx,ny,nz;

	T temp;

};
/////////////////////////////////////////////////////////////////////////////////////////////////



/************************************************************************************************/
/********************************** Constructeur/Destructeur ************************************/
/************************************************************************************************/

/////////////////////////////////////////////////////////////////////////////////////////////////
// Constructeur de la classe Tab3D.
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> Tableau3D<T>::Tableau3D()
{
	Tableau3D<T>::adr1=0;		nx=0;
	Tableau3D<T>::adr2=0;		ny=0;
	Tableau3D<T>::tab3D=0;		nz=0;
}




/////////////////////////////////////////////////////////////////////////////////////////////////
// Constructeur de la classe Tab3D.
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> Tableau3D<T>::Tableau3D(int _nx, int _ny, int _nz)
{
	Tableau3D<T>::Create(_nx,_ny,_nz);
}



/////////////////////////////////////////////////////////////////////////////////////////////////
// Destructeur de la classe Tab3D.
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> Tableau3D<T>::~Tableau3D()
{
	Tableau3D<T>::Delete();
}








/************************************************************************************************/
/************************************ Gestion de tableaux 3D ************************************/
/************************************************************************************************/

/////////////////////////////////////////////////////////////////////////////////////////////////
// Création de tableaux 3D
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> bool Tableau3D<T>::Create(int _nx, int _ny, int _nz)
{
	// Création de tableau possible
	if (_nx>0 && _ny>0 && _nz>0)
	{
		// Création du tableau
		Tableau3D<T>::adr1  = new T[_nx*_ny*_nz];
		Tableau3D<T>::adr2  = new T*[_nx*_ny];
		Tableau3D<T>::tab3D = new T**[_nx];

		// Vérification
		if (Tableau3D<T>::adr1!=0 && Tableau3D<T>::adr2!=0 && Tableau3D<T>::tab3D!=0)
		{
			// Initialisation de la taille
			nx=_nx;		ny=_ny;		nz=_nz;

			for (int j=0; j<ny*nx; j++)
				Tableau3D<T>::adr2[j]  = Tableau3D<T>::adr1 + j*nz;
			for (int i=0; i<nx; i++)
				Tableau3D<T>::tab3D[i] = Tableau3D<T>::adr2 + i*ny;

			return true;
		}
	}

	// Pas de tableau créé
	Tableau3D<T>::Delete();
	return false;
}



/////////////////////////////////////////////////////////////////////////////////////////////////
// Suppression de tableaux 3D
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> void Tableau3D<T>::Delete()
{
	if (!Tableau3D<T>::adr1)	delete[] Tableau3D<T>::adr1;
		Tableau3D<T>::adr1=0;	nx=0;
	if (!Tableau3D<T>::adr2)	delete[] Tableau3D<T>::adr2;
		Tableau3D<T>::adr2=0;	ny=0;
	if (!Tableau3D<T>::tab3D)	delete[] Tableau3D<T>::tab3D;
		Tableau3D<T>::tab3D=0;	nz=0;
}



/////////////////////////////////////////////////////////////////////////////////////////////////
// Existence de tableaux 3D
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> bool Tableau3D<T>::Existing()
{
	if (Tableau3D<T>::adr1!=0)	return true;
	else				return false;
}



/////////////////////////////////////////////////////////////////////////////////////////////////
// Initialisation du tableau 3D
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> void Tableau3D<T>::Initialize(T val)
{
	for (int i=0; i<nx; i++)
	for (int j=0; j<ny; j++)
	for (int k=0; k<nz; k++)
		tab3D[i][j][k] = val;
}







/************************************************************************************************/
/*********************************** Présence dans le tableau ***********************************/
/************************************************************************************************/

/////////////////////////////////////////////////////////////////////////////////////////////////
// La case est-elle dans le tableau ?
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> bool Tableau3D<T>::InTable (int _nx, int _ny, int _nz )
{
	return (Tableau3D<T>::InTableX(_nx) &&
		Tableau3D<T>::InTableY(_ny) &&
		Tableau3D<T>::InTableZ(_nz));
}



/////////////////////////////////////////////////////////////////////////////////////////////////
// La ligne x est-elle dans le tableau ?
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> bool Tableau3D<T>::InTableX (int _nx)
{
	if (_nx<0 ||_nx>=nx)	return false;
	else			return true;
}



/////////////////////////////////////////////////////////////////////////////////////////////////
// La ligne y est-elle dans le tableau ?
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> bool Tableau3D<T>::InTableY (int _ny)
{
	if (_ny<0 ||_ny>=ny)	return false;
	else			return true;
}



/////////////////////////////////////////////////////////////////////////////////////////////////
// La ligne z est-elle dans le tableau ?
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> bool Tableau3D<T>::InTableZ (int _nz)
{
	if (_nz<0 ||_nz>=nz)	return false;
	else			return true;
}








/************************************************************************************************/
/*********************************** Taille mémoire du tableau **********************************/
/************************************************************************************************/

/////////////////////////////////////////////////////////////////////////////////////////////////
// Taille en mémoire du tableau
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> unsigned long Tableau3D<T>::Memoire()
{
	int POINTEUR=4;
	unsigned long M = nx*ny*nz*sizeof(T) + POINTEUR		// Taille de adr1
			+ nx*ny*POINTEUR     + POINTEUR		// Taille de adr2
			+ nx*POINTEUR	     + POINTEUR;	// Taille de adr2

	return M;
}








/************************************************************************************************/
/******************************** Extraction de données du tableau ******************************/
/************************************************************************************************/

/////////////////////////////////////////////////////////////////////////////////////////////////
// Extraire une donnée du tableau après vérification d'existence
/////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> T& Tableau3D<T>::Extract(int _nx, int _ny, int _nz)
{
	if (Tableau3D<T>::adr1!=0)	return tab3D[_nx][_ny][_nz];
	else				return temp;
}
	

#endif