Comment dire le compilateur de ne PAS optimiser certains le code?

La compilateur ne peut pas optimiser un corps de fonction de suite, si vous déclarez qu'il extern ou pas, car il ne peut pas savoir que la fonction n'est pas appelée à partir d'une autre unité de compilation. Il pourrait optimiser loin si vous avez déclaré il statique, mais je ne t en croire les compilateurs de faire ça.

Le compilateur peut optimiser loin des appels de fonction:

while(false) {
  foo();
}

Au-dessus de l'appel à foo() peut être gommés.

Otoh, que, le de l'éditeur de liens peut supprimer la fonction des organes de la finale excecutable si ils ne sont pas appelés.

Pour ces raisons et d'autres, nous avons vraiment besoin de voir une partie de code réel afin de diagnostiquer votre problème.

OriginalL'auteur

Le compilateur est l'optimisation de loin une variable qui n'est jamais utilisé, il ne peut pas optimiser une fonction au motif qu'il ne sera pas utilisé, car il pourrait être utilisé à partir d'une autre unité de compilation. Vous pouvez essayer de forcer le compilateur en considérant la variable utilisée avec quelque chose qui ressemble à:

void instantiation()
{
   Foo<int> f;
   f; //mark the variable as if it is used.
}

//or:
Foo<int>* instantiation()
{
   Foo<int> *p = new Foo<int>();
   return p; //The compiler cannot know if p will be used, it must compile
}

Serait une meilleure solution pour instancier explicitement le modèle si vous le souhaitez:

//.h
template <typename T>
class Foo
{
public:
   Foo( T const & value );
   void set( T const & ); //whatever else
private:
   T value_;
};

//template implementation another file, not included from .h
//instantiation.cpp??
template <typename T>
Foo<T>::Foo<T>( T const & value ) : value_(value) {}

template <typename T>
void Foo<T>::set( T const & v )
{
   value_ = value;
}

//explicit instantiation
template class Foo<int>;
template class Foo<double>;

//test.cpp
#include "header.h"
int main()
{
    Foo<int> f(5);
    f.set( 7 );

    Foo<char> f2; //linker error Foo<char>() not defined
}

Le code de l'utilisateur ne verra que les en-tête et de savoir quelles méthodes existent, mais pas la mise en œuvre réelle. La mise en œuvre seront compilées dans une unité de compilation, où l'explicite l'instanciation d'un modèle se produit.

Notez que si vous oubliez de les instancier explicitement un type, ce sera une erreur de l'éditeur de liens, pas d'erreur de compilation.

Une Définition De La Règle

Une définition de la règle en c++ états qu'il peut y avoir une seule définition pour chaque symbole ou de la classe. Le fait d'avoir plusieurs définitions peuvent être facilement détectés pour les symboles classiques (si vous définissez deux void f() { } l'éditeur de liens détecter le double symbole), mais est un peu plus délicat avec des modèles. Avec des modèles, il est plus difficile car ils sont généralement déclarées et définies dans les fichiers d'en-tête. Le compilateur génère les symboles utilisés dans chaque unité de compilation [1] et le linker les trouve souvent plus d'un symbole équivalent ( std::vector::push_back() est compilé dans chaque unité de compilation qui a un std::vector et des appels push_back)

Les drapeaux du compilateur l'basées sur des modèles de code comme "faible", symbole, ce qui signifie que, tandis que le symbole est défini ici, elle peut également être définie dans une autre unité de compilation et de l'éditeur de liens est libre de jeter le symbole sans céder une erreur de lien. C'est une exigence si vous souhaitez lier les différentes unités de compilation qui font usage de la même STL installations, par exemple, avec les mêmes types.

Jusqu'à gcc 4.2, gcc linux de l'éditeur de liens ignore tout, mais la faiblesse des symboles sans autre vérification. Certains linkers (gcc éditeur de liens dans linux sera dans un futur proche, non pas comme 4.2, je ne sais pas 4.3 ni 4.4 il pourrait être déjà là) ne vérifier que les différents "faible", les symboles sont en fait les mêmes et fournir un message d'erreur/d'avertissement à l'utilisateur.

Votre code est rupture l'ODR en ce que vous êtes redeclaring le modèle dans un endroit différent. Vous devez déclarer le modèle une fois, et de mettre en œuvre les méthodes de l'extérieur comme affiché ci-dessus. De toute façon si les deux définitions sont compatibles (comme ils le sont dans l'extrait de code que vous avez posté): tous les membres de méthodes et d'attributs sont exactement les mêmes et avec les mêmes qualificatifs (virtuel/const-ness...), il doit être accepté par le compilateur comme il y a une seule définition de l'alas (répété) du modèle.

[1] Uniquement les méthodes qui sont appelés dans le code sera compilé:

template <typename T>
struct Test
{
   void f() { std::cout << "f()" << std::endl; }
   void g() { std::cout << "g()" << std::endl; }
};
int main()
{
   Test<int> t;
   t.f(); //compiler generates Test<int>::f, but not Test<int>::g
}

OriginalL'auteur David Rodríguez - dribeas

Hors part, je ne suis pas sûr. Peut-être Les en-têtes précompilés permettra de résoudre ce problème?

Juste à modifier un peu tout ça, évidemment, ce n'est pas aider avec le problème d'être en mesure d'utiliser le plus petit modèle d'en-tête dans votre code, mais il pourrait aider à la compilation problème de temps (et donc de supprimer la nécessité pour le modèle).

OriginalL'auteur Bill Lynch