J'espère que vous passez (ou avez passé) de bonnes vacances.
En ces temps estivaux, j'ai écrit une application dans laquelle j'ai
définit des templates. L'un d'entre eux est :
Une partie des fonction est définie dans un fichier <engine-impl.h>,
qui est un fichier contenant les définition des plus grosses fonctions
que je ne souhaite pas rendre inline. Donc j'ai un fichier <engine.cpp>
dans lequel je force l'« instantiation » des templates :
#include "engine-impl.h"
template class search_engine <std::wstring> ;
Vu que les fonctions correspondant à ces instantiations de template
sont déjà disponible, j'aimerais le signaler dans le fichier d'en-tête
<engine.h>. C'est surtout pour prévenir les problèmes d'édition de lien
liés à une déclaration multiples des fonctions. Pour ce faire, j'ai
rajouté :
class search_engine <std::wstring> ;
Mais contrairement aux classes normales, cela entraîne des erreurs
sur l'instantiation explicite de mes template.
Y a-t-il une méthode plus propre permettant de prévenir que certains
templates sont instanciés ? (j'ai essayé avec typedef et extern, mais
rien n'y fait).
Je compile avec g++ 4.3.1 sous Debian GNU/Linux. L'erreur suivante
survient lorsque je tente de déclarer un template instancié :
explicit instantiation of ‘struct
warg::search_engine<std::basic_string<wchar_t, std::char_
traits<wchar_t>, std::allocator<wchar_t> >, std::basic_string<wchar_t,
std::char_traits<wchar_t>, std::allocator<wc
har_t> > >’ before definition of template
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Fabien LE LEZ
On Mon, 18 Aug 2008 22:20:05 +0200, Mickaël Wolff :
C'est surtout pour prévenir les problèmes d'édition de lien liés à une déclaration multiples des fonctions.
J'ai peur de ne pas tout suivre. Quels problèmes as-tu exactement ? Peux-tu donner un code minimal (mais complet) qui illustre le problème ?
class search_engine <std::wstring> ; Mais contrairement aux classes normales, cela entraîne des erreurs sur l'instantiation explicite de mes template.
Je ne saisis pas bien ce que tu veux faire, mais j'ai l'impression que tu mélanges l'instanciation d'une classe template, et instanciation de ses fonctions membres.
Prends l'exemple du code suivant :
#include <string>
template <class T> class C { public: void f() { T::foo(); } };
class HasFoo { public: static void foo() {} };
int main() { C <HasFoo> c_foo; // 1 c_foo.f(); // 2
C <std::string> c_string; // 3 // c_string.f(); // 4 }
En (1), la classe C<HasFoo> est instanciée. En (2), la fonction C<HasFoo>::f() est instanciée. En (3), la classe C<std::string> est instanciée.
En (4), la fonction C<std::string>::f() ne peut pas être instanciée, car std::string::foo() n'existe pas. (J'ai mis le code en commentaire car il est erronné.)
On Mon, 18 Aug 2008 22:20:05 +0200, Mickaël Wolff
<mickael.wolff@laposte.net>:
C'est surtout pour prévenir les problèmes d'édition de lien
liés à une déclaration multiples des fonctions.
J'ai peur de ne pas tout suivre. Quels problèmes as-tu exactement ?
Peux-tu donner un code minimal (mais complet) qui illustre le
problème ?
class search_engine <std::wstring> ;
Mais contrairement aux classes normales, cela entraîne des erreurs
sur l'instantiation explicite de mes template.
Je ne saisis pas bien ce que tu veux faire, mais j'ai l'impression que
tu mélanges l'instanciation d'une classe template, et instanciation de
ses fonctions membres.
Prends l'exemple du code suivant :
#include <string>
template <class T> class C
{
public: void f() { T::foo(); }
};
class HasFoo
{
public: static void foo() {}
};
int main()
{
C <HasFoo> c_foo; // 1
c_foo.f(); // 2
C <std::string> c_string; // 3
// c_string.f(); // 4
}
En (1), la classe C<HasFoo> est instanciée.
En (2), la fonction C<HasFoo>::f() est instanciée.
En (3), la classe C<std::string> est instanciée.
En (4), la fonction C<std::string>::f() ne peut pas être instanciée,
car std::string::foo() n'existe pas. (J'ai mis le code en commentaire
car il est erronné.)
On Mon, 18 Aug 2008 22:20:05 +0200, Mickaël Wolff :
C'est surtout pour prévenir les problèmes d'édition de lien liés à une déclaration multiples des fonctions.
J'ai peur de ne pas tout suivre. Quels problèmes as-tu exactement ? Peux-tu donner un code minimal (mais complet) qui illustre le problème ?
class search_engine <std::wstring> ; Mais contrairement aux classes normales, cela entraîne des erreurs sur l'instantiation explicite de mes template.
Je ne saisis pas bien ce que tu veux faire, mais j'ai l'impression que tu mélanges l'instanciation d'une classe template, et instanciation de ses fonctions membres.
Prends l'exemple du code suivant :
#include <string>
template <class T> class C { public: void f() { T::foo(); } };
class HasFoo { public: static void foo() {} };
int main() { C <HasFoo> c_foo; // 1 c_foo.f(); // 2
C <std::string> c_string; // 3 // c_string.f(); // 4 }
En (1), la classe C<HasFoo> est instanciée. En (2), la fonction C<HasFoo>::f() est instanciée. En (3), la classe C<std::string> est instanciée.
En (4), la fonction C<std::string>::f() ne peut pas être instanciée, car std::string::foo() n'existe pas. (J'ai mis le code en commentaire car il est erronné.)
Mickaël Wolff
Fabien LE LEZ a écrit :
J'ai peur de ne pas tout suivre. Quels problèmes as-tu exactement ? Peux-tu donner un code minimal (mais complet) qui illustre le problème ?
Je ne peux pas spécifier dans un en-tête qu'une instantiation de template existe déjà.
Je ne saisis pas bien ce que tu veux faire, mais j'ai l'impression que tu mélanges l'instanciation d'une classe template, et instanciation de ses fonctions membres.
D'après mes essais, l'instantiation explicite de la template instancie les fonctions membre de la classe template.
Prends l'exemple du code suivant :
[snip]
En (1), la classe C<HasFoo> est instanciée. En (2), la fonction C<HasFoo>::f() est instanciée. En (3), la classe C<std::string> est instanciée.
Effectivement, ça j'ai bien compris. C'est le principe de base de la STL. J'ai écrit un petit exemple, que je mets en fin de message. Je fais juste une parenthèse pour dire que ce que je présente ici fonctionne très bien. Mon seul soucis, c'est que dans le fichier d'en-tête (tpl.h dans l'exemple, et non tpl-impl.h), les templates instanciés ne sont pas déclarés, et qu'il m'est impossible de faire un typedef sans avoir d'erreurs.
== <main.cpp> ====== 8< ===== #include "tpl.h"
int main(int argc, char ** argv) { // pas d'instantiation, puisque déjà instancié engine<std;;string> e("The street") ; e.walk() ; }
== <tpl.cpp> ====== 8< ===== #include "tpl-imp.h"
// On force l'instanciation du template en utilisant // l'instanciation explicite : template class engine<std::string> ;
J'ai peur de ne pas tout suivre. Quels problèmes as-tu exactement ?
Peux-tu donner un code minimal (mais complet) qui illustre le
problème ?
Je ne peux pas spécifier dans un en-tête qu'une instantiation de
template existe déjà.
Je ne saisis pas bien ce que tu veux faire, mais j'ai l'impression que
tu mélanges l'instanciation d'une classe template, et instanciation de
ses fonctions membres.
D'après mes essais, l'instantiation explicite de la template
instancie les fonctions membre de la classe template.
Prends l'exemple du code suivant :
[snip]
En (1), la classe C<HasFoo> est instanciée.
En (2), la fonction C<HasFoo>::f() est instanciée.
En (3), la classe C<std::string> est instanciée.
Effectivement, ça j'ai bien compris. C'est le principe de base de la
STL. J'ai écrit un petit exemple, que je mets en fin de message. Je fais
juste une parenthèse pour dire que ce que je présente ici fonctionne
très bien. Mon seul soucis, c'est que dans le fichier d'en-tête (tpl.h
dans l'exemple, et non tpl-impl.h), les templates instanciés ne sont pas
déclarés, et qu'il m'est impossible de faire un typedef sans avoir
d'erreurs.
== <main.cpp> ====== 8< ===== #include "tpl.h"
int main(int argc, char ** argv)
{
// pas d'instantiation, puisque déjà instancié
engine<std;;string> e("The street") ;
e.walk() ;
}
== <tpl.cpp> ====== 8< ===== #include "tpl-imp.h"
// On force l'instanciation du template en utilisant
// l'instanciation explicite :
template class engine<std::string> ;
J'ai peur de ne pas tout suivre. Quels problèmes as-tu exactement ? Peux-tu donner un code minimal (mais complet) qui illustre le problème ?
Je ne peux pas spécifier dans un en-tête qu'une instantiation de template existe déjà.
Je ne saisis pas bien ce que tu veux faire, mais j'ai l'impression que tu mélanges l'instanciation d'une classe template, et instanciation de ses fonctions membres.
D'après mes essais, l'instantiation explicite de la template instancie les fonctions membre de la classe template.
Prends l'exemple du code suivant :
[snip]
En (1), la classe C<HasFoo> est instanciée. En (2), la fonction C<HasFoo>::f() est instanciée. En (3), la classe C<std::string> est instanciée.
Effectivement, ça j'ai bien compris. C'est le principe de base de la STL. J'ai écrit un petit exemple, que je mets en fin de message. Je fais juste une parenthèse pour dire que ce que je présente ici fonctionne très bien. Mon seul soucis, c'est que dans le fichier d'en-tête (tpl.h dans l'exemple, et non tpl-impl.h), les templates instanciés ne sont pas déclarés, et qu'il m'est impossible de faire un typedef sans avoir d'erreurs.
== <main.cpp> ====== 8< ===== #include "tpl.h"
int main(int argc, char ** argv) { // pas d'instantiation, puisque déjà instancié engine<std;;string> e("The street") ; e.walk() ; }
== <tpl.cpp> ====== 8< ===== #include "tpl-imp.h"
// On force l'instanciation du template en utilisant // l'instanciation explicite : template class engine<std::string> ;
Il me semble me souvenir que gcc fournit cela comme extension depuis longtemps, mais j'ai pas le temps de regarder.
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Mickaël Wolff <mickael.wolff@laposte.net> writes:
Fabien LE LEZ a écrit :
J'ai peur de ne pas tout suivre. Quels problèmes as-tu exactement ?
Peux-tu donner un code minimal (mais complet) qui illustre le problème ?
Je ne peux pas spécifier dans un en-tête qu'une instantiation de template
existe déjà.
extern template devrait resoudre ton probleme dans C++0X, si je l'ai bien
compris.
Il me semble me souvenir que gcc fournit cela comme extension depuis
longtemps, mais j'ai pas le temps de regarder.
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Il me semble me souvenir que gcc fournit cela comme extension depuis longtemps, mais j'ai pas le temps de regarder.
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
James Kanze
On Aug 18, 10:20 pm, Mickaël Wolff wrote:
En ces temps estivaux, j'ai écrit une application dans laquelle j'ai définit des templates. L'un d'entre eux est :
Une partie des fonction est définie dans un fichier <engine-impl.h>, qui est un fichier contenant les définition des plus grosses fonctions que je ne souhaite pas rendre inline. Donc j'ai un fichier <engine.cpp> dans lequel je force l'« instantiation » des templates :
#include "engine-impl.h"
template class search_engine <std::wstring> ;
Vu que les fonctions correspondant à ces instantiations de template sont déjà disponible, j'aimerais le signaler dans le fichier d'en-t ête <engine.h>. C'est surtout pour prévenir les problèmes d'édition de lien liés à une déclaration multiples des fonctions. Pour ce faire, j'ai rajouté :
class search_engine <std::wstring> ;
Mais contrairement aux classes normales, cela entraîne des erreurs sur l'instantiation explicite de mes template.
Y a-t-il une méthode plus propre permettant de prévenir que certai ns templates sont instanciés ? (j'ai essayé avec typedef et extern, mais rien n'y fait).
Je ne suis pas sûr ce que dit la norme à cet égard ; je crois rien. Mais dans la practique, si la définition d'un tempate dont le compilateur a besoin n'est pas disponible lors de la compilation, le compilateur « suppose » qu'il a été instantié ailleur.
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
On Aug 18, 10:20 pm, Mickaël Wolff <mickael.wo...@laposte.net> wrote:
En ces temps estivaux, j'ai écrit une application dans laquelle j'ai
définit des templates. L'un d'entre eux est :
Une partie des fonction est définie dans un fichier <engine-impl.h>,
qui est un fichier contenant les définition des plus grosses fonctions
que je ne souhaite pas rendre inline. Donc j'ai un fichier <engine.cpp>
dans lequel je force l'« instantiation » des templates :
#include "engine-impl.h"
template class search_engine <std::wstring> ;
Vu que les fonctions correspondant à ces instantiations de template
sont déjà disponible, j'aimerais le signaler dans le fichier d'en-t ête
<engine.h>. C'est surtout pour prévenir les problèmes d'édition de lien
liés à une déclaration multiples des fonctions. Pour ce faire, j'ai
rajouté :
class search_engine <std::wstring> ;
Mais contrairement aux classes normales, cela entraîne des erreurs
sur l'instantiation explicite de mes template.
Y a-t-il une méthode plus propre permettant de prévenir que certai ns
templates sont instanciés ? (j'ai essayé avec typedef et extern, mais
rien n'y fait).
Je ne suis pas sûr ce que dit la norme à cet égard ; je crois
rien. Mais dans la practique, si la définition d'un tempate dont
le compilateur a besoin n'est pas disponible lors de la
compilation, le compilateur « suppose » qu'il a été instantié
ailleur.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Une partie des fonction est définie dans un fichier <engine-impl.h>, qui est un fichier contenant les définition des plus grosses fonctions que je ne souhaite pas rendre inline. Donc j'ai un fichier <engine.cpp> dans lequel je force l'« instantiation » des templates :
#include "engine-impl.h"
template class search_engine <std::wstring> ;
Vu que les fonctions correspondant à ces instantiations de template sont déjà disponible, j'aimerais le signaler dans le fichier d'en-t ête <engine.h>. C'est surtout pour prévenir les problèmes d'édition de lien liés à une déclaration multiples des fonctions. Pour ce faire, j'ai rajouté :
class search_engine <std::wstring> ;
Mais contrairement aux classes normales, cela entraîne des erreurs sur l'instantiation explicite de mes template.
Y a-t-il une méthode plus propre permettant de prévenir que certai ns templates sont instanciés ? (j'ai essayé avec typedef et extern, mais rien n'y fait).
Je ne suis pas sûr ce que dit la norme à cet égard ; je crois rien. Mais dans la practique, si la définition d'un tempate dont le compilateur a besoin n'est pas disponible lors de la compilation, le compilateur « suppose » qu'il a été instantié ailleur.
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
