Tableau 3d générique

Commenter

Contenu du snippet

Ce code permet de gérer des tableaux 3D génériques, c'est à dire des tableaux 3D soit d'int, de float, ou même d'autres types de données :
- Création d'un tableau 3D
- Suppression d'un tableau 3D
- Vérification d'existence
- Coût en espace mémoire du tableau 3D
- Initialisation à une valeur donnée
- ...

Source / Exemple : 


/////////////////////////////////////////////////////////////////////////////////////////////////
//
// 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

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (xkamen)