Wie kann man feststellen, ob etwas ein Container ist?

Question

Ich möchte feststellen, ob etwas ein Container ist. Im Moment teste ich es an Containern, die einen Typ und einen Zuweiser haben. Mein ultimatives Ziel ist es, zu lernen, wie man eine Containervorlage schreibt, die, wenn sie Layer von sich selbst enthält, eine direkte Iteration ihrer innersten Elemente erlaubt. Z.B. Wenn es einen Container mit 3 Containern gibt, von denen jeder 3 weitere Container enthält, von denen jeder 3 Elemente enthält, möchte ich in der Lage sein, alle 27 Elemente in einem Bereich basierend auf der Schleife zu durchlaufen. Unterscheidend, ob etwas ein Container ist, der direkt Elemente enthält oder Container von Elementen (oder Containern von Containern ... von Containern von Elementen enthält), die SFINAE verwenden, um zu überprüfen, ob das Element einen Iterator hat, scheint ein logischer erster Schritt in Richtung der begin() Funktion zu sein sollte den Iterator an das Element oder das Ergebnis der begin() Funktion dieses Elements zurückgeben. Wenn ich meinen ersten Schritt arbeiten kann, würde Ich mag diese Logik enthalten in meinem Container zu schreiben, aber ich kann es nicht kompilieren erhalten:

#include <vector> 
#include <iostream> 

template <typename T, 
    template <typename E, typename Allocator = std::allocator<E>> class Container 
> 
void is_cont(typename Container<T>::iterator it) 
{ 
    std::cout << "is iterator\n"; 
} 

template <typename T, 
    template <typename E, typename Allocator = std::allocator<E>> class Container 
> 
void is_cont(Container<T>& cont) 
{ 
    std::cout << "is container\n"; 
} 

int main() 
{ 
    std::vector<int> vec{ 2, 4, 6 }; 
    is_cont(vec);    // Output: "is container" 
    //is_cont(vec.begin());  // COMPILER ERROR 
} 

Wie kann ich dieses Problem beheben?

Answer 1

Ihre Definition, ob etwas ein Container ist oder nicht, basiert ausschließlich darauf, ob er eine iterator innere Klasse hat.

Das ist so gut wie eine Heuristik, nehme ich an, aber lassen Sie uns damit gehen.

In den meisten Fällen ist SFINAE viel einfacher, wenn es mit Klassen gemacht wird, anstatt zu versuchen, SFINAE mit einer Funktion zu implementieren, wie Ihre is_container(). Machen Sie Ihre is_container() in eine Klasse führt zu einer folgenden Lehrbuch SFINAE Lösung:

#include <vector> 
#include <string> 
#include <iostream> 
#include <type_traits> 

template<typename ...> 
using void_t=void; 

template<typename T, class=void> struct is_container : std::false_type {}; 

template<typename T> 
struct is_container<T, void_t<typename T::iterator>> : std::true_type {}; 

int main() 
{ 
    std::cout << is_container<int>::value << std::endl; 

    std::cout << is_container<std::vector<int>>::value << std::endl; 
    return 0; 
} 

Nun wäre eine damit verbundene Frage, ob sein gibt es eine bessere Art und Weise zu überprüfen, ob etwas ein Behälter ist, oder nicht. Unabhängig davon, welche Heuristik Sie wählen, es ist trivial, einen klassenbasierten Test anstelle eines funktionsbasierten Tests anzupassen. Zum Beispiel, wenn Sie zu prüfen, ob etwas ein Behälter ist, wenn es beide iterator und const_iterator inneren Klassen hat, muss nur eine Zeile ändern:

template<typename T> 
struct is_container<T, void_t<typename T::iterator, 
           typename T::const_iterator>> : std::true_type {};