Проверка во время компиляции - это тип шаблона вектора

Ответ 1

Он называется тегом диспетчеризации:

#include <vector>
#include <set>
#include <type_traits>

template<typename T> struct is_vector : public std::false_type {};

template<typename T, typename A>
struct is_vector<std::vector<T, A>> : public std::true_type {};

template <typename T>
class X {
    T container;

    void foo( std::true_type ) {
        container.push_back(0);
    }
    void foo( std::false_type ) {
        container.insert(0);
    }
public:
    void foo() {
        foo( is_vector<T>{} );
    }
};

// somewhere else...
int main() {
    X<std::vector<int>> abc;
    abc.foo();

    X<std::set<int>> def;
    def.foo();
}

Ответ 2

Альтернативный подход - обнаружить присутствие функции push_back с помощью SFINAE. Это немного более общий, поскольку он переведёт на другие контейнеры, реализующие push_back.

template<typename T>
struct has_push_back
{
    template<typename U>
    static std::true_type test(
        decltype((void(U::*)(const typename U::value_type&)) &U::push_back)*);

    template<typename>
    static std::false_type test(...);

    typedef decltype(test<T>(0)) type;
    static constexpr bool value = 
        std::is_same<type, std::true_type>::value;
};

Обратите внимание, что в настоящее время он обнаруживает только push_back(const T&), а не push_back(T&&). Обнаружение обоих немного сложнее.

Вот как вы его используете, чтобы на самом деле сделать вставку.

template<typename C, typename T>
void push_back_impl(C& cont, const T& value, std::true_type) {
    cont.push_back(value);
}

template<typename C, typename T>
void push_back_impl(C& cont, const T& value, std::false_type) {
    cont.insert(value);
}

template<typename C, typename T>
void push_back(C& cont, const T& value) { 
    push_back_impl(cont, value, has_push_back<C>::type());
}

std::vector<int> v;
push_back(v, 1);

std::set<int> s;
push_back(s, 1);

Честно говоря, это решение стало намного сложнее, чем я первоначально ожидал, поэтому я бы не использовал его, если вам это действительно не нужно. Хотя не так сложно поддерживать const T& и T&&, это еще более загадочный код, который вы должны поддерживать, что, вероятно, не стоит в большинстве случаев.

Ответ 3

Использование только вставки:

#include <iostream>
#include <vector>
#include <set>

template <typename T>
class X
{
    public:
    T container;

    template <typename U>
    void insert(const U& u) {
        container.insert(container.end(), u);
    }
};

int main() {
    X<std::vector<int>> v;
    v.insert(2);
    v.insert(1);
    v.insert(0);

    for(std::vector<int>::const_iterator pos = v.container.begin();
        pos != v.container.end();
        ++pos)
    {
        std::cout << *pos;
    }
    std::cout << '\n';

    X<std::set<int>> s;
    s.insert(2);
    s.insert(1);
    s.insert(0);

    for(std::set<int>::const_iterator pos = s.container.begin();
        pos != s.container.end();
        ++pos)
    {
        std::cout << *pos;
    }
    std::cout << '\n';
}

Ответ 4

Здесь типичный метод, использующий void_t:

template <typename T>
using void_t = void;  // C++17 std::void_t

template <typename C, typename = void>  // I'm using C for "container" instead of T, but whatever.
struct has_push_back_impl : std::false_type {};

template <typename C>
struct has_push_back_impl<C, void_t<decltype(std::declval<C>().push_back(typename C::value_type{}))>>
    : std::true_type {};  // Note that void_t is technically not needed in this case, since the 'push_back' member function actually returns void anyway, but it the general method to pass the type into void_t template argument to obtain void.  For example, the 'insert' function from std::set and std::map do NOT return void, so 'has_insert' will need to use void_t.

template <typename C>
using has_push_back = has_push_back_impl<C>;  // void passed to the second template argument by default, thus allowing the second specialization to be used instead of the primary template whenever C has a push_back member function.

Этот метод будет работать для has_insert для ассоциативных контейнеров, даже если std::set, std::map insert возвращает функцию std::pair<typename T::iterator, bool>, а std::multimap::insert возвращает std::multimap::iterator (это один случай, когда метод Ze Blob будет не работает).

Ответ 5

Если вы используете constexpr if, вы делаете это правильно. Этот код С++ 17 компилируется:

#include <iostream>
#include <type_traits>
#include <vector>
#include <list>

template<typename T> struct is_vector : public std::false_type {};

template<typename T, typename A>
struct is_vector<std::vector<T, A>> : public std::true_type {};


template <typename T>
class X
{
  public:
   T container;

   void foo()
   {
      if constexpr(is_vector<T>::value){
        std::cout << "I am manipulating a vector" << std::endl;
        // Can access container.push_back here without compilation error
      }
      else {
         std::cout << "I am manipulating something else" << std::endl;
      }
   }
};

int main() {
    X<std::vector<int>> abc;
    abc.foo(); // outputs "I am manipulating a vector"

    X<std::list<int>> def;
    def.foo(); // outputs "I am manipulating something else"
}