C++11

Problem

template<typename T>
struct A {
  typedef int result_type;

  void f() {
    // error, "this" is dependent, "template" keyword needed
    this->g<float>();

    // OK
    g<float>();

    // error, "A<T>" is dependent, "typename" keyword needed
    A<T>::result_type n1;

    // OK
    result_type n2; 
  }

  template<typename U>
  void g();
};

Jak widać, potrzebujemy słowa kluczowego disambiguation, nawet jeśli kompilator potrafi sam się doskonale zorientować, że A::result_type może być tylko int (a więc jest typem), a {[9] } może być tylko szablonem member g zadeklarowanym później (nawet jeśli A jest gdzieś wyraźnie wyspecjalizowany, to nie będzie to wpływaj na kod w tym szablonie, więc na jego znaczenie nie może mieć wpływ późniejsza specjalizacja A!).

Obecna instancja

Aby poprawić sytuację, w C++11 język śledzi, gdy typ odnosi się do załączającego szablonu. Aby to wiedzieć, rodzaj musi być utworzony przez użycie określonej formy nazwy, która jest nazwą własną (w powyższym, A, A<T>, ::A<T>). Typ, do którego odnosi się taka nazwa, jest znany jako current instantiation . Mogą być wieloma typami, które są wszystkimi bieżącymi instancjami, jeśli typ, z którego została utworzona nazwa, jest klasą składową / zagnieżdżoną (wtedy A::NestedClass i {[11] } są bieżącymi instancjami).

Opierając się na tym pojęciu, język mówi, że CurrentInstantiation::Foo, Foo i CurrentInstantiationTyped->Foo (takie jak A *a = this; a->Foo) są wszystkie członkami bieżącej instancji jeśli są członkami klasy, która jest bieżącą instancją lub jedną z jej nie zależnych klas bazowych (wykonując tylko nazwę wyszukiwanie od razu).

Słowa kluczowe typename i template nie są już wymagane, jeśli kwalifikator jest członkiem bieżącej instancji. Należy pamiętać, że A<T> jest nadal nazwą zależną od typu (w końcu {[25] } jest również zależna od typu). Ale A<T>::result_type jest znany jako typ - kompilator" magicznie " zajrzy do tego rodzaju zależnych typów, aby to zrozumieć.

struct B {
  typedef int result_type;
};

template<typename T>
struct C { }; // could be specialized!

template<typename T>
struct D : B, C<T> {
  void f() {
    // OK, member of current instantiation!
    // A::result_type is not dependent: int
    D::result_type r1;

    // error, not a member of the current instantiation
    D::questionable_type r2;

    // OK for now - relying on C<T> to provide it
    // But not a member of the current instantiation
    typename D::questionable_type r3;        
  }
};

template<>
struct C<int> {
  typedef bool result_type;
  typedef int questionable_type;
};

Kompilator jest wymagany do wychwycenia błędu podczas tworzenia instancji D<int>::f. Więc masz najlepsze z dwóch światów: "opóźnione" lookup chroniąc cię, jeśli możesz wpadnij w kłopoty z zależnymi klasami bazowymi, a także" natychmiastowym " wyszukiwaniem, które uwalnia cię od typename i template.

Nieznane specjalizacje

W kodzie D nazwa typename D::questionable_type nie jest członkiem bieżącej instancji. Zamiast tego język oznacza go jako członka nieznanej specjalizacji. W szczególności jest tak zawsze, gdy wykonujesz DependentTypeName::Foo lub DependentTypedName->Foo i albo typem zależnym jest , a nie bieżąca instancja (w takim przypadku kompilator może zrezygnować i powiedzieć: "przyjrzymy się później, czym jest Foo) lub to jest bieżąca instancja i nazwa nie została znaleziona w niej lub jej nie zależnych klasach bazowych i istnieją również zależne klasy bazowe.

Wyobraź sobie, co się stanie, jeśli będziemy mieli funkcję member h Wewnątrz wyżej zdefiniowanego A szablonu klasy

void h() {
  typename A<T>::questionable_type x;
}

W C++03 język pozwalał wychwycić ten błąd, ponieważ nigdy nie było poprawnego sposobu na utworzenie instancji A<T>::h (niezależnie od argumentu give to T). W C++11 język ma teraz kolejną kontrolę, aby dać więcej powodów dla kompilatorów do implementacji tej reguły. Ponieważ A nie ma zależnych klas bazowych i A nie deklaruje żadnego członka questionable_type, nazwa A<T>::questionable_type nie jestani członkiem bieżącej instancji , ani członkiem nieznanej specjalizacji. W takim przypadku nie powinno być możliwości, aby ten kod mógł poprawnie skompilować się w czasie tworzenia instancji, więc język zabrania nazwy, w której kwalifikatorem jest bieżący instancja nie jest członkiem nieznanej specjalizacji ani członkiem aktualnej instancji (jednak naruszenie to nadal nie jest wymagane do rozpoznania).

Przykłady i ciekawostki

Możesz wypróbować tę wiedzę na tej odpowiedzi i sprawdzić, czy powyższe definicje mają dla ciebie sens na prawdziwym przykładzie (są one powtarzane nieco mniej szczegółowo w tej odpowiedzi).

Reguły C++11 sprawiają, że poniższy poprawny kod C++03 jest nieprawidłowy (co nie było zamierzone przez Komitet C++, ale prawdopodobnie nie zostanie naprawione)

struct B { void f(); };
struct A : virtual B { void f(); };

template<typename T>
struct C : virtual B, T {
  void g() { this->f(); }
};

int main() { 
  C<A> c; c.g(); 
}

Ten poprawny kod C++03 wiązałby this->f do A::f w czasie tworzenia instancji i wszystko jest w porządku. C++11 jednak natychmiast wiąże go z B::f i wymaga podwójnego sprawdzenia podczas tworzenia instancji, sprawdzając, czy odnośnik nadal pasuje. Jednak podczas tworzenia instancji C<A>::g, stosuje się regułę dominacji i lookup znajdzie A::f.

Przedmowa

[[34]}ten post ma być łatwą do odczytania alternatywą dla posta litba .

Podstawowy cel jest taki sam; wyjaśnienie do "kiedy?"i" dlaczego?"typename i template muszą być stosowane.

Jaki jest cel typename i template?

typename i template są użyteczne w okolicznościach innych niż przy deklarowaniu szablonu.

Istnieją pewne konteksty w C++ gdzie kompilator musi być wyraźnie poinformowany, jak traktować nazwę, a wszystkie te konteksty mają jedną wspólną cechę; zależą od co najmniej jednego template-parameter .

Odnosimy się do takich nazw, w których może występować niejednoznaczność w interpretacji, jak; " nazwy zależne ".

Ten post oferuje Wyjaśnienie zależności między zależnymi nazwami , a dwoma słowami kluczowymi.

FRAGMENT MÓWI PONAD 1000 SŁÓW

Spróbuj wyjaśnij, co dzieje się w poniższym function-template , samemu sobie, przyjacielowi, a może kotowi; co dzieje się w wyrażeniu oznaczonym (A )?

template<class T> void f_tmpl () { T::foo * x; /* <-- (A) */ }

Może to nie być takie proste, jak się wydaje, a dokładniej wynik oceny (A) w dużym stopniu zależy od definicji typu przekazanego jako parametr szablonu T.

Różne Ts mogą drastycznie zmienić semantykę zaangażowany.

struct X { typedef int       foo;       }; /* (C) --> */ f_tmpl<X> ();
struct Y { static  int const foo = 123; }; /* (D) --> */ f_tmpl<Y> ();

Dwa różne scenariusze :

• Jeśli utworzymy szablon funkcji z typem X , tak jak w ( C), będziemy mieli deklarację wskaźnika-do into nazwie x, ale;

• Jeśli tworzymy szablon z typem Y , jak w (D), (A ) składa się z wyrażenia, które oblicza iloczyn 123 pomnożona przez pewną już zadeklarowaną zmienną x .

UZASADNIENIE

Standard C++ dba o nasze bezpieczeństwo i Dobre Samopoczucie, przynajmniej w tym przypadku.

Aby zapobiec potencjalnym niespodziankom w implementacji, Standard nakazuje uporządkowanie niejednoznaczności zależnej Nazwy przez jawnie stwierdzając intencję wszędzie, gdzie chcielibyśmy traktować nazwę jako a type-name , or a template-id .

Jeśli nic nie jest podane, nazwa zależna będzie uważana za zmienną lub funkcję.

JAK OBCHODZIĆ SIĘ ZZALEŻNYMI NAZWAMI ?

A nazwa zależna to dowolna nazwa , która bezpośrednio lub pośrednio zależy od parametru szablonu .

template<class T> void g_tmpl () {
   SomeTrait<T>::type                   foo; // (E), ill-formed
   SomeTrait<T>::NestedTrait<int>::type bar; // (F), ill-formed
   foo.data<int> ();                         // (G), ill-formed    
}

Mamy cztery zależne nazwy w powyższym fragmencie:

• E )
  • "typ" zależy od instancji SomeTrait<T>, które obejmują T, oraz;
• F )
  • "NestedTrait" , który jest szablon-id , zależy od SomeTrait<T>, oraz;
  • "typ"na końcu ( F ) zależy od NestedTrait , który zależy od SomeTrait<T>, oraz;
• G )
  • "data" , który wygląda jak szablon member-function , jest pośrednio zależną nazwą , ponieważ Typ foo zależy od instancji SomeTrait<T>.

Żaden z statement (E), (F) lub ( G ) jest poprawne, jeśli kompilator zinterpretuje zależne-Nazwy jako zmienne/funkcje (co, jak wspomniano wcześniej, dzieje się, jeśli nie mówimy wprost inaczej).

ROZWIĄZANIE

Aby g_tmplmiała poprawną definicję, musimy wyraźnie powiedzieć kompilatorowi, że oczekujemy typu in ( E), a template-idi a typein ( F) oraz template-idin ( G ).

template<class T> void g_tmpl () {
   typename SomeTrait<T>::type foo;                            // (G), legal
   typename SomeTrait<T>::template NestedTrait<int>::type bar; // (H), legal
   foo.template data<int> ();                                  // (I), legal
}

Za każdym razem gdy nazwa oznacza typ, wszystkie Nazwy muszą być albo type-names albo namespaces , mając to na uwadze, łatwo zauważyć, że stosujemy typename na początku naszej W pełni kwalifikowanej nazwy.

template Jednak jest inaczej pod tym względem, ponieważ nie ma sposobu, aby dojść do wniosku, takiego jak; " Och, to jest szablon, niż ten inny rzecz musi być również szablonem " . Oznacza to, że stosujemy template bezpośrednio przed dowolną nazwą, którą chcielibyśmy traktować jako taką.

CZY MOGĘ PO PROSTU UMIEŚCIĆ SŁOWA KLUCZOWE PRZED DOWOLNĄ NAZWĄ?

"Czy mogę trzymać typename i template przed jakimkolwiek imieniem? Nie chcę się martwić kontekstem, w jakim się pojawiają..." - Some C++ Developer

Reguły w standardzie mówią, że możesz zastosować słowa kluczowe tak długo, jak masz do czynienia z kwalifikowanym-imieniem (K), ale jeśli nazwa nie jest kwalifikowana Aplikacja jest źle utworzona ( L ).

namespace N {
  template<class T>
  struct X { };
}

         N::         X<int> a; // ...  legal
typename N::template X<int> b; // (K), legal
typename template    X<int> c; // (L), ill-formed

^{Uwaga : stosowanie typename lub template w kontekście, w którym nie jest to wymagane, nie jest uważane za dobrą praktykę; to, że możesz coś zrobić, nie oznacza, że powinieneś.}

Dodatkowo istnieją konteksty gdzie typename i template są jawnie wyłączone:

• Kiedy określamy bazy, których klasa dziedziczy

  Każda nazwa zapisana w liście typów pochodnych base-specifier-list {[40] } jest już traktowana jako nazwa typu , jawnie określająca typename jest zarówno źle uformowana, jak i zbędna.

                     // .------- the base-specifier-list
   template<class T> // v
   struct Derived      : typename SomeTrait<T>::type /* <- ill-formed */ {
     ...
   };
  

  
  

• Gdy template-id jest tym, do którego odnosi się klasa pochodna using-directive

   struct Base {
     template<class T>
     struct type { };
   };
  
   struct Derived : Base {
     using Base::template type; // ill-formed
     using Base::type;          // legal
   };
  

typedef typename Tail::inUnion<U> dummy;

Jednak nie jestem pewien, czy implementacja inUnion jest poprawna. Jeśli dobrze rozumiem, ta klasa nie powinna być tworzona jako instancja, dlatego zakładka "fail"nigdy nie zawiedzie. Może lepiej byłoby wskazać, czy typ jest w Unii, czy nie za pomocą prostej wartości logicznej.

template <typename T, typename TypeList> struct Contains;

template <typename T, typename Head, typename Tail>
struct Contains<T, UnionNode<Head, Tail> >
{
    enum { result = Contains<T, Tail>::result };
};

template <typename T, typename Tail>
struct Contains<T, UnionNode<T, Tail> >
{
    enum { result = true };
};

template <typename T>
struct Contains<T, void>
{
    enum { result = false };
};

PS: spójrz na Boost:: Variant

_{ta odpowiedź ma być dość krótka i słodka, aby odpowiedzieć (część) tytułowego pytania. Jeśli chcesz uzyskać bardziej szczegółową odpowiedź, która wyjaśnia, dlaczego musisz je tam umieścić, idź tutaj .}

Ogólna zasada wprowadzania słowa kluczowego typename jest najczęściej wtedy, gdy używasz parametru szablonu i chcesz uzyskać dostęp do zagnieżdżonego typedef lub używając-aliasu, na przykład:

template<typename T>
struct test {
    using type = T; // no typename required
    using underlying_type = typename T::type // typename required
};

Zauważ, że dotyczy to również funkcji meta lub rzeczy, które przyjmują ogólne parametry szablonu. Jeśli jednak Podany parametr szablonu jest jawnym typem, nie musisz podawać typename, na przykład:

template<typename T>
struct test {
    // typename required
    using type = typename std::conditional<true, const T&, T&&>::type;
    // no typename required
    using integer = std::conditional<true, int, float>::type;
};

Ogólne zasady dodawania kwalifikatora template są w większości podobne, z wyjątkiem tego, że zazwyczaj dotyczą szablonowych funkcji składowych (statycznych lub innych) struktury / klasy, która sama jest szablonowa, na przykład:

Biorąc pod uwagę tę strukturę i funkcję:

template<typename T>
struct test {
    template<typename U>
    void get() const {
        std::cout << "get\n";
    }
};

template<typename T>
void func(const test<T>& t) {
    t.get<int>(); // error
}

Próba dostępu t.get<int>() z wnętrza funkcja spowoduje błąd:

main.cpp:13:11: error: expected primary-expression before 'int'
     t.get<int>();
           ^
main.cpp:13:11: error: expected ';' before 'int'

Tak więc w tym kontekście należy wcześniej użyć słowa kluczowego template i nazwać go w ten sposób:

t.template get<int>()

W ten sposób kompilator przetworzy to poprawnie, a nie t.get < int.

Umieszczam doskonałą odpowiedź JLBorges na podobne pytanie od cplusplus.com, ponieważ jest to najbardziej zwięzłe wyjaśnienie, jakie czytałem na ten temat.

W szablonie, który piszemy, istnieją dwa rodzaje nazw, które mogą być użyte - nazwy zależne i nazwy niezależne. Nazwa zależna to nazwa zależna od parametru szablonu; nazwa zależna ma takie samo znaczenie niezależnie od parametrów szablonu.

Dla przykład:

template< typename T > void foo( T& x, std::string str, int count )
{
    // these names are looked up during the second phase
    // when foo is instantiated and the type T is known
    x.size(); // dependant name (non-type)
    T::instance_count ; // dependant name (non-type)
    typename T::iterator i ; // dependant name (type)

    // during the first phase, 
    // T::instance_count is treated as a non-type (this is the default)
    // the typename keyword specifies that T::iterator is to be treated as a type.

    // these names are looked up during the first phase
    std::string::size_type s ; // non-dependant name (type)
    std::string::npos ; // non-dependant name (non-type)
    str.empty() ; // non-dependant name (non-type)
    count ; // non-dependant name (non-type)
}

To, do czego odnosi się nazwa zależna, może być czymś innym dla każdej innej instancji szablonu. W związku z tym szablony C++ podlegają "dwufazowemu wyszukiwaniu nazw". Gdy szablon jest wstępnie parsowany (przed jakąkolwiek instancją), kompilator wyszukuje nazwy nie zależne. Gdy dana instancja szablonu ma miejsce, parametry szablonu są znane do tego czasu, a kompilator wyszukuje nazwy zależne.

Podczas pierwszej fazy parser musi wiedzieć, czy nazwa zależna jest nazwą typu, czy nazwą Nie-typu. Domyślnie przyjmuje się, że nazwa zależna jest nazwą typu innego niż typ. Słowo kluczowe typename przed nazwą zależną określa, że jest to nazwa typu.

Podsumowanie

Używaj słowa kluczowego typename tylko w deklaracjach i definicjach szablonu, pod warunkiem, że masz kwalifikowaną nazwę, która odnosi się do typu i zależy od szablonu parametr.