Utilisation des templates ;-)

Question sommaire concernant les templates.

Si à plusieurs fois dans un code je déclare plusieurs variables de type
auto_ptr<TypeVariable>,
est-ce qu'il existera en mémoire plusieurs instances de cette classe ?

Il n'y a pas de raisons, mais le compilateur est libre de faire comme il
souhaite. Potentiellement, on pourrait imaginer des cas où ça pourrait
être intéressant de dupliquer (pour une variable, il vaut mieux avoir
telle fonction inline, pour l'autre non), mais pas plus que si on crée
deux variables d'une même classe non template.

Je constate qu'à chaque fois que je fais appel à un template, la taille
de mon executable augmente très fortement.

Ah ? Et n'est-ce pas du simplement à la taille pour stocker cette variable ?

--
Loïc

Loïc Joly wrote:

Je constate qu'à chaque fois que je fais appel à un template, la
taille de mon executable augmente très fortement.

Ah ? Et n'est-ce pas du simplement à la taille pour stocker cette
variable ?

Je vois comme une ambiguïté sur le terme "exécutable" dans cette discussion.

Stephane Wirtel wrote:

Je constate qu'à chaque fois que je fais appel à un template, la
taille de mon executable augmente très fortement.

Faut voir ce que signifie très fortement.
BCB possède un smart linker il me semble. Donc il vire toutes les fonctions
(de la lib standard entre autre) qui ne sont pas utilisées (à moins que tu
compiles pour utiliser une dll). Si ton template fait appel à des fonctions
qui jusque là n'étaient utilisées nul part, peut être est-ce une
explication...

--
Aurélien REGAT-BARREL

Stephane Wirtel wrote:

Question sommaire concernant les templates.

Si à plusieurs fois dans un code je déclare plusieurs
variables de type auto_ptr<TypeVariable>, est-ce qu'il
existera en mémoire plusieurs instances de cette classe ?

Qu'est-ce que tu entends par « instances » ? Normalement, on
dirait qu'il y a une instance par variable, plus une instance
par temporaire. Mais ce sont des objets créés lors de
l'exécution, et qui ne se trouvent pas dans le fichier
exécutable.

Je constate qu'à chaque fois que je fais appel à un template,
la taille de mon executable augmente très fortement.

Chaque fois que tu l'instancies avec des paramètres différents,
c'est normal que la taille de l'exécutable augmente. De combien,
ça dépend du template -- pour auto_ptr, je m'attendrais à assez
peu.

Je pensais que le compilateur factorisait les appels de
templates semblables et ne crée qu'une seule classe
descriptive du template, ceci afin de gagner de la place
mémoire.

Qu'est-ce que tu entends par « semblables » ? Si les paramètres
sont différents, il faut que les adresses des fonctions soient
différentes. Si les paramètres sont identiques, il faut que
les adresses soient les mêmes partout. En fin de compte, le
compilateur n'a pas beaucoup de liberté là-dedans. Sauf,
évidemment, s'il optimise ; il peut bien mettre les appels de
fonction inline, par exemple.

--
James Kanze GABI Software
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

Si les paramètres sont identiques, il faut que
les adresses soient les mêmes partout.

Pour les fonctions qui ne dépendent pas du tout du paramètre, il peut
utiliser la même fonction.
Pour les fonctions qui ne dépendent du paramètre qu'en un endroit bien
précis, il pourrait découper la fonction en une fonction qui dépend du
paramètre et une fonction qui n'en dépend pas.
Par exemple (bidon comme il se doit)

template<class T>
void write(const T& t)
{
std::string s = boost::lexical_cast(t);
//Traitement long qui n'utilise que s
}

Pourait être remplacé par

template<class T>
void write(const T& t)
{
traitementLong(boost::lexical_cast(t));
}
void traitementLong(const std::string& s)
{
//Traitement long qui n'utilise que s
}

--
Vincent

Vincent Lascaux wrote:

Si les paramètres sont identiques, il faut que
les adresses soient les mêmes partout.

Pour les fonctions qui ne dépendent pas du tout du paramètre,
il peut utiliser la même fonction.

Pour les fonctions qui ne dépendent du paramètre qu'en un
endroit bien précis, il pourrait découper la fonction en une
fonction qui dépend du paramètre et une fonction qui n'en
dépend pas. Par exemple (bidon comme il se doit)

template<class T>
void write(const T& t)
{
std::string s = boost::lexical_cast(t);
//Traitement long qui n'utilise que s
}

Pourait être remplacé par

template<class T>
void write(const T& t)
{
traitementLong(boost::lexical_cast(t));
}
void traitementLong(const std::string& s)
{
//Traitement long qui n'utilise que s
}

Ce n'est pas si évident que ça. Si traitementLong contient une
variable statique, par exemple, il faut qu'il y ait une instance
par instantiation du template.

Sinon, ça exige une certaine intelligencee du compilateur. Plus
que ce qui est actuellement courante. C'est faisable, mais les
compilateurs actuels qui poussent l'analyse au maximum le font
en général en vue d'optimiser les temps d'exécution, non pour
minimiser la taille de l'exécutable. Ajouter un appel de
fonction là où il n'y avait pas dans la source, ça n'améliore
pas le temps d'exécution (mais si le traitement est long, ça ne
doit pas le rendre pire de façon mésurable non plus).

--
James Kanze GABI Software
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