Discussion :

[darkman19320]

Bonjour tout le monde,

Je cherche une m�thode afin d'exporter une version compil�e de mes templates au sein d'une biblioth�que sans pour autant fournir le fichier du template.

Est-ce faisable?

Merci

[SkyZoThreaD]

Une version compil�e de templates c++ ? �a ne fait pas sens pour moi vu que les templates sont utilis�s � la compilation
Ou ai-je mal compris la question ?

[darkman19320]

Oui, je me suis mal exprim�. En fait, j'ai un template repr�sentant des images. Ces images peuvent �tre soient de type float soit de type entier par exemple. Je voulais �viter de donner l'impl�mentation de cette classe template en ne donnant juste leur "sp�cialisation" (en utilisant typedef par exemple).

[SkyZoThreaD]

Oui si comme j'ai compris, c'est le type de donn�es qui est templatis�, tu dois pouvoir faire un typedef dans un header.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
template<typename T>
class mine
{
public:
	mine(T v):d(v){}
private:
	T d;
};
 
 
typedef mine<int> mineint;
typedef mine<float> minefloat;

[ternel]

Tu peux passer par une astuce: la sp�cialisation de type incomplet:
La classe template n'est pas d�finie dans le cas g�n�ral, et est sp�cialis�e pour deux cas pr�cis

L'en-t�te contiendrait:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
template <typename T>
class Bidule; //surtout pas d'accolades
 
template <>
class Bidule<int> {
   // ce que tu veux
};
 
template <typename T>
class Bidule<float> {
   // ce que tu veux
};

[darkman19320]

Merci pour vos r�ponses.

@SkyZoThreaD: le probl�me avec cette m�thode, c'est que j'exporte le template ce que je souhaite.

@leternel: je ne souhaite pas vraiment sp�cialiser les templates, mais plut�t les d�finir.

Mon but est d'�viter d'inclure certains en-t�te entra�nant des d�pendances ind�sirables.

Voici un exemple:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
// Dans Image.hxx  qui ne serait pas exporté
#include <header_indesirable.hpp>
 
template<typename T>
class Image
{
public:
  Image(){}
  void method(); // Méthode qui utilise header_indesirable.hpp
private:
  T m_data;
};
 
template<typename T>
void method()
{
// du code
}
 
// Dans ImageImpl.hpp qui serait exporté
 
typedef Image<int> ImageInt;
typedef Image<float> ImageFloat;

Je ne vois vraiment pas si c'est possible mais bon, peut-�tre qu'il existe une petite astuce sympa pour ce genre de probl�me.

[SkyZoThreaD]

@SkyZoThreaD: le probl�me avec cette m�thode, c'est que j'exporte le template ce que je souhaite

Donc c'est ce que tu souhaites ? Je vais consid�rer que tu ne le souhaites pas
Je ne comprend toujours pas bien la question, mais il me semble que tu veux pr�compiler des templates non sp�cifi�s et comme je l'ai �cris avant il me semble que c'est impossible. Les templates sont utilis�s � la compilation...

[darkman19320]

Donc c'est ce que tu souhaites ? Je vais consid�rer que tu ne le souhaites pas

Effectivement, je ne le souhaite pas ^^

Je ne comprend toujours pas bien la question, mais il me semble que tu veux pr�compiler des templates non sp�cifi�s et comme je l'ai �cris avant il me semble que c'est impossible. Les templates sont utilis�s � la compilation...

Effectivement, je souhaite pr�compiler mes templates pour les cas que j'ai sp�cifi� (des images en int et en float). Apr�s, j'ai une solution, recoder la classe sans utilis� de template mais bon c'est un peu lourd ^^

[SkyZoThreaD]

Ok tout est clair maintenant
Donc je ne pense pas que ce soit possible mais attend la r�ponse d'un plus cal� que moi. Le c++ est si tortueux... sait-on jamais...

[Pyramidev]

C'est possible.

Voici un exemple illustratif :

CartableCasse.h :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef MODELE_PAS_DEFINI_DANS_ENTETE_CARTABLE_CASSE
#define MODELE_PAS_DEFINI_DANS_ENTETE_CARTABLE_CASSE
 
#include <iostream>
 
class CartableCasse
{
public:
	void car()   const { std::cout << "CartableCasse::car()\n";   }
	void table() const { std::cout << "CartableCasse::table()\n"; }
	void casse() const { std::cout << "CartableCasse::casse()\n"; }
};
 
#endif

CartoucheCasse.h :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef MODELE_PAS_DEFINI_DANS_ENTETE_CARTOUCHE_CASSE
#define MODELE_PAS_DEFINI_DANS_ENTETE_CARTOUCHE_CASSE
 
#include <iostream>
 
class CartoucheCasse
{
public:
	void car()    const { std::cout << "CartoucheCasse::car()\n";    }
	void touche() const { std::cout << "CartoucheCasse::touche()\n"; }
	void casse()  const { std::cout << "CartoucheCasse::casse()\n";  }
};
 
#endif

MonModele.h :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#ifndef MODELE_PAS_DEFINI_DANS_ENTETE_MON_MODELE
#define MODELE_PAS_DEFINI_DANS_ENTETE_MON_MODELE
 
template<class T>
class MonModele
{
private:
	T m_data;
public:
	void carcasse()  const;
	void cartable()  const;
	void cartouche() const;
};
 
#endif

MonModele_impl.h :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#ifndef MODELE_PAS_DEFINI_DANS_ENTETE_MON_MODELE_IMPL
#define MODELE_PAS_DEFINI_DANS_ENTETE_MON_MODELE_IMPL
 
#include "MonModele.h"
 
template<class T>
void MonModele<T>::carcasse() const
{
	m_data.car();
	m_data.casse();
}
 
template<class T>
void MonModele<T>::cartable() const
{
	m_data.car();
	m_data.table();
}
 
template<class T>
void MonModele<T>::cartouche() const
{
	m_data.car();
	m_data.touche();
}
 
#endif

MonModeleCartableCasse.cpp :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
#include "CartableCasse.h"
#include "MonModele_impl.h"
 
// Instancier les fonctions qui compilent pour T = CartableCasse :
template void MonModele<CartableCasse>::carcasse() const;
template void MonModele<CartableCasse>::cartable() const;

MonModeleCartoucheCasse.cpp :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
#include "CartoucheCasse.h"
#include "MonModele_impl.h"
 
// Instancier les fonctions qui compilent pour T = CartoucheCasse :
template void MonModele<CartoucheCasse>::carcasse()  const;
template void MonModele<CartoucheCasse>::cartouche() const;

main.cpp :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "MonModele.h"
#include "CartableCasse.h"
#include "CartoucheCasse.h"
 
#include <iostream>
 
int main()
{
    MonModele<CartableCasse> foo;
    foo.carcasse();
    foo.cartable();
 
    std::cout << '\n';
 
    MonModele<CartoucheCasse> bar;
    bar.carcasse();
    bar.cartouche();
 
    return 0;
}

Sortie :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
CartableCasse::car()
CartableCasse::casse()
CartableCasse::car()
CartableCasse::table()
 
CartoucheCasse::car()
CartoucheCasse::casse()
CartoucheCasse::car()
CartoucheCasse::touche()

[dalfab]

Bonjour,

En utilisant les extern template, et en for�ant les instanciations on peut aussi le faire sur la classe enti�re
fichier .h

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef DLLMASQUEE
  #define DLLIMP __declspec(dllimport)
#else
  #define DLLIMP __declspec(dllexport)
#endif
 
template<class T> class DLLIMP Masquee {
	T x;
public:
	Masquee(T const x) : x{ x } {}
	T action()const;
};

fichier .cpp

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
#define DLLMASQUEE
#include "Masquee.h"
 
template<class T> T Masquee<T>::action()const {
	return 2 * x;
}
 
template class Masquee<int>; // forcer l'instanciation des cas int et float
template class Masquee<float>;

On pourra alors utiliser les Masquee<> qui ont �t� instanci�es dans la DLL.

[Pyramidev]

Je me rends compte que mon exemple pr�c�dent �tait inutilement compliqu�.
J'ai cr�� un exemple un peu plus simple qui utilise aussi l'astuce que viens de donner dalfab :

Car.h :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef MODELE_PAS_DEFINI_DANS_ENTETE_CAR
#define MODELE_PAS_DEFINI_DANS_ENTETE_CAR
 
#include <iostream>
 
class Car
{
public:
	void car() const { std::cout << "Car::car()\n"; }
};
 
#endif

Cartable.h :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef MODELE_PAS_DEFINI_DANS_ENTETE_CARTABLE
#define MODELE_PAS_DEFINI_DANS_ENTETE_CARTABLE
 
#include <iostream>
 
class Cartable
{
public:
	void car()   const { std::cout << "Cartable::car()\n";   }
	void table() const { std::cout << "Cartable::table()\n"; }
};
 
#endif

DoubleAction_light.h :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef MODELE_PAS_DEFINI_DANS_ENTETE_DOUBLE_ACTION_LIGHT
#define MODELE_PAS_DEFINI_DANS_ENTETE_DOUBLE_ACTION_LIGHT
 
#include <iostream>
 
template<class T>
class DoubleAction
{
private:
	T m_data;
public:
	DoubleAction() { std::cout << "DoubleAction constructor\n"; }
	~DoubleAction();
	void doubleCar()   const;
	void doubleTable() const;
};
 
#endif

DoubleAction.h :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#ifndef MODELE_PAS_DEFINI_DANS_ENTETE_DOUBLE_ACTION
#define MODELE_PAS_DEFINI_DANS_ENTETE_DOUBLE_ACTION
 
#include "DoubleAction_light.h"
 
template<class T>
DoubleAction<T>::~DoubleAction()
{
	std::cout << "DoubleAction destructor\n";
}
 
template<class T>
void DoubleAction<T>::doubleCar() const
{
	m_data.car();
	m_data.car();
}
 
template<class T>
void DoubleAction<T>::doubleTable() const
{
	m_data.table();
	m_data.table();
}
 
#endif

DoubleAction_Car_Cartable.cpp :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
#include "Car.h"
#include "Cartable.h"
#include "DoubleAction.h"
 
// Instancier les fonctions qui compilent pour T = Car :
template DoubleAction<Car>::~DoubleAction();
template void DoubleAction<Car>::doubleCar() const;
 
// Instancier toute la classe pour T = Cartable :
template class DoubleAction<Cartable>;

Main.cpp :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include "Car.h"
#include "Cartable.h"
#include "DoubleAction_light.h"
 
#include <iostream>
 
int main()
{
    DoubleAction<Car> foo;
    foo.doubleCar();
 
    std::cout << '\n';
 
    DoubleAction<Cartable> bar;
    bar.doubleCar();
    bar.doubleTable();
 
    std::cout << '\n';
 
    return 0;
}

Sortie :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
DoubleAction constructor
Car::car()
Car::car()
 
DoubleAction constructor
Cartable::car()
Cartable::car()
Cartable::table()
Cartable::table()
 
DoubleAction destructor
DoubleAction destructor

[darkman19320]

Super!
Merci pour vos conseils!
Je viens de faire des tests et je vais utiliser la m�thode de dalfab plut�t.

Voici mon petit exemple de test avec les fichiers CMake associ�s (j'ai test� sous Visual Studio 2010 et 2015).
ExportPreCompiledTemplate.zip