Opaque Zeiger mit Schablonen Mitglieder auf struct

Question

Angenommen, ich baue eine verkettete Liste (die reale Datenstruktur ist völlig anders, aber eine verknüpfte Liste reicht für die Frage), dessen Knoten aussehen

template <typename T> 
struct node 
{ 
    struct node<T> *next; 
    T data; 
}; 

Für meine Daten Struktur, ich habe viele Funktionen mit Rückgabetyp struct node *, und ich möchte der Benutzer diesen Typ als undurchsichtig behandeln. Im Beispiel der verknüpften Liste könnte eine solche Funktion beispielsweise get_next(struct node<T> *n) oder insert_after(struct node<T> *x, struct node<T> *y) sein. Nur sehr wenige Funktionen, nämlich diejenigen, die node s zuweisen oder ihr data Feld bekommen, müssen etwas über T wissen.

Gibt es eine schönere Möglichkeit, "T" zu ignorieren und den Benutzer nur mit etwas wie einem typedef struct node * opaque_handle für die Funktionen interagieren zu lassen, die sich nie um T kümmern müssen? Meine Bauchreaktion, die von C kommt, ist nur zu und von void* zu werfen, aber das klingt nicht sehr elegant.

Edit: CygnusX1 des comment hat mich überzeugt, dass ich zur gleichen Zeit für zu viele Garantien vom Typ System bin gefragt, die ich versuche, zu viele dieser Garantien zu umgehen. Ich werde darauf zurückfallen, Tvoid * auf Kosten von Gießen und Indirektion zu sein.

Answer 1

Während Sie sich nicht interessieren, was T ist, möchten Sie es am meisten von einem anderen Typ unterscheiden - sagen Sie U, nicht wahr? Sie wollen wahrscheinlich die folgenden um einen Fehler zu erhöhen:

node<T>* elem1 = ... 
node<U>* elem2 = ... 
elem1 = elem2 

Es gibt ein paar Möglichkeiten, um Ihren Code einfacher zu machen, ohne die Typprüfung zu verzichten oder Laufzeit perforamce:

• Wenn Sie C verwenden + +11 betrachten auto anstelle von ausdrücklich auf die Art der Benennung, wenn Ihre Funktionen
• Wenn node<T> in Ihrem Code sehr häufig, können Sie festlegen, einen globalen Rahmen typedef

Beachten Sie auch, dass im Zusammenhang mit der node<T> Definition eine einfache node (ohne Vorlagenargumente) erlaubt ist.

Wenn Sie den Inhalt des node wirklich ausblenden möchten, können Sie das pimpl Muster wie von mvidelgauz vorgeschlagen implementieren.

Answer 2

Wenn Sie boost verwenden können, kann boost :: any oder boost :: variant helfen, heterogene Container zu implementieren.

ist so etwas wie das, was Sie nach ?:

#include <iostream> 
#include <boost/any.hpp> 
#include <list> 

using Collection = std::list<boost::any>; 
using Node = Collection::iterator; 

static Collection anys; 

template<typename T> 
Node insert_after(T const& obj, Node start_pos = anys.end()) 
{ 
    return anys.insert(start_pos, boost::any(obj)); 
} 

void print_type(boost::any const& a) 
{ 
    if (a.type() == typeid(int)) { std::cout << "int" << std::endl; } 
    else if (a.type() == typeid(float)) { std::cout << "float" << std::endl; } 
} 

int main() 
{ 
    const auto node1 = insert_after(int(1)); 
    const auto node2 = insert_after(float(2.57)); 
    const auto node3 = insert_after(int(3)); 

    std::cout << boost::any_cast<int>(*node1) << std::endl; 
    std::cout << boost::any_cast<float>(*node2) << std::endl; 
    std::cout << boost::any_cast<int>(*node3) << std::endl; 

    print_type(*node1); 
    print_type(*node2); 
    print_type(*node3); 

    return 0; 
} 

Ausgänge:

1 
2.57 
3 
int 
float 
int