C++ Vorlage Klassensyntax

Question

In meiner Klasse studieren wir C++ 98, also versuche ich, die richtige Syntax zu finden.

Wie sollte man die Erklärung schreiben:

template <class T> 
class A{ 
public: 
    A(); 
    A(const A &rhs); 
    A &operator=(const A &rhs); 
}; 

Oder sollte es so sein:

template <class T> 
class A{ 
public: 
    A(); 
    A(const A<T> &rhs); 
    A &operator=(const A<T> &rhs); 
}; 

Ich denke, die Umsetzung das gleiche ist für beide.

Sind sie voneinander verschieden?

Answer 1

Bei

template <class T> class A { ... }; 

Die Namen A<T> und A sind beiden gültigen Namen zu A<T> im Rahmen der Klasse zu verweisen. Die meisten bevorzugen die einfachere Form A, aber Sie können A<T> verwenden.

Answer 2

Während R Sahu ‚s Antwort richtig ist, ich denke, es ist gut, um den Fall zu veranschaulichen, wo A nicht die gleichen wie A<T> ist, insbesondere dort, wo es mehr als 1 instanziiert Template-Argument ist.

Wenn Sie beispielsweise einen Kopierkonstruktor für eine Vorlagenklasse mit zwei Vorlagenargumenten schreiben, müssen Sie die Vorlagen für die Überladungen explizit ausschreiben, da die Reihenfolge der Argumente von Bedeutung ist. Hier

ist ein Beispiel mit einer "Schlüssel/Wert" Typenklasse:

#include <iostream> 

// Has overloads for same class, different template order 
template <class Key, class Value> 
struct KV_Pair { 
    Key  key; 
    Value value; 

    // Correct order 
    KV_Pair(Key key, Value value) : 
     key(key), 
     value(value) {} 

    // Automatically correcting to correct order 
    KV_Pair(Value value, Key key) : 
     key(key), 
     value(value) {} 

    // Copy constructor from class with right template order 
    KV_Pair(KV_Pair<Value, Key>& vk_pair) : 
     key(vk_pair.value), 
     value(vk_pair.key) {} 

    // Copy constructor from class with "wrong" template order 
    KV_Pair(KV_Pair<Key, Value>& vk_pair) : 
     key(vk_pair.key), 
     value(vk_pair.value) {} 
}; 

template <class Key, class Value> 
std::ostream& operator<<(std::ostream& lhs, KV_Pair<Key, Value>& rhs) { 
    lhs << rhs.key << ' ' << rhs.value; 
    return lhs; 
} 

int main() { 
    // Original order 
    KV_Pair<int, double> kv_pair(1, 3.14); 

    std::cout << kv_pair << std::endl; 

    // Automatically type matches for the reversed order 
    KV_Pair<double, int> reversed_order_pair(kv_pair); 

    std::cout << reversed_order_pair << std::endl; 
} 

See it live on Coliru.