Punkt instancji

Szablony zostaną utworzone, gdy są faktycznie używane

Kompilatory nie muszą jednak poprawnie implementować Poi: błąd c++/ 41995: niepoprawny punkt instancji dla funkcji szablon

Częściowa instancja

Szablony zostaną utworzone, gdy są faktycznie używane

To jest częściowo poprawne. To prawda w przypadku szablonów funkcji, ale w przypadku szablonów klas tworzy się instancje tylko funkcji Członkowskich, które są używane. Poniższy jest dobrze uformowany kod:

#include <iostream>

template <typename> struct Foo {
    void let_me_stay() {
        this->is->valid->code. get->off->my->lawn;
    }

    void fun() { std::cout << "fun()" << std::endl; } 
};


int main () {
    Foo<void> foo;
    foo.fun();
}

let_me_stay() jest sprawdzana składniowo (a składnia jest poprawna), ale nie semantycznie (tzn. nie jest interpretowane).

Wyszukiwanie dwufazowe

Jednak dopiero kod zależny jest interpretowany później; wyraźnie, w Foo<>, this zależy od dokładnego ID szablonu, z którym Foo<> jest tworzona instancja, więc odłożyliśmy sprawdzanie błędów Foo<>::let_me_alone() do czasu tworzenia instancji.

Ale jeśli nie używamy czegoś, co zależy od konkretnej instancji, kod musi być dobry. Dlatego poniżej znajduje się nie dobrze uformowany:

$ cat non-dependent.cc
template <typename> struct Foo {
    void I_wont_compile() { Mine->is->valid->code. get->off->my->lawn; }
};
int main () {} // note: no single instantiation

Mine jest zupełnie nieznanym symbolem dla kompilatora, w przeciwieństwie do this, dla którego kompilator może określić jego zależność od instancji.

Kluczowym punktem jest tutaj to, że C++ używa modelu two-phase-lookup , gdzie sprawdza kod nie zależny w pierwszej fazie, a semantyczne sprawdzanie kodu zależnego odbywa się w fazie drugiej (i czas instancji) (jest to również często niezrozumiane lub nieznane pojęcie, wielu programistów C++ zakłada, że że szablony nie są w ogóle przetwarzane aż do momentu utworzenia, ale to tylko mit pochodzący z, ..., Microsoft C++).

Pełna instancja szablonów klas

Definicja Foo<>::let_me_stay() zadziałała, ponieważ sprawdzanie błędów zostało przełożone na później, jak dla wskaźnika this, który jest zależny. Chyba, że skorzystałbyś z

Jawne instancje

cat > foo.cc
#include <iostream>

template <typename> struct Foo {
    void let_me_stay() { this->is->valid->code. get->off->my->lawn; }
    void fun() { std::cout << "fun()" << std::endl; } 
};

template struct Foo<void>;
int main () {
    Foo<void> foo;
    foo.fun();
}

g++ foo.cc
error: error: ‘struct Foo<void>’ has no member named ‘is’

Definicje szablonów w różnych jednostkach tłumaczenie

Kiedy jawnie tworzysz instancję, jawnie tworzysz instancję. I sprawiają, że wszystkie symbole są widoczne dla linkera, co oznacza również, że definicja szablonu może znajdować się w różnych jednostkach tłumaczenia:

$ cat A.cc
template <typename> struct Foo {
    void fun();  // Note: no definition
};
int main () {
    Foo<void>().fun();
}

$ cat B.cc
#include <iostream>
template <typename> struct Foo {
    void fun();

};
template <typename T>
void Foo<T>::fun() { 
    std::cout << "fun!" << std::endl;
}  // Note: definition with extern linkage

template struct Foo<void>; // explicit instantiation upon void

$ g++ A.cc B.cc
$ ./a.out
fun!

Należy jednak jawnie utworzyć instancję dla wszystkich argumentów szablonu, w przeciwnym razie

$ cat A.cc
template <typename> struct Foo {
    void fun();  // Note: no definition
};
int main () {
    Foo<float>().fun();
}
$ g++ A.cc B.cc
undefined reference to `Foo<float>::fun()'

Mała uwaga na temat wyszukiwania dwufazowego: to, czy kompilator faktycznie implementuje wyszukiwanie dwufazowe, nie jest podyktowane przez standard. Na być zgodne, jednak powinno działać tak, jakby tak było (tak jak dodawanie lub mnożenie niekoniecznie musi być wykonywane za pomocą instrukcji dodawania lub mnożenia procesora.