Проверьте наличие глобального оператора << в C++

Question

Здравствуйте, я хочу написать две реализации функции-члена to_string следующим образом:

template <typename T0> class foo
{
public: std::string     to_string();
public: T0              m_Value;
};

template <typename T0> std::string foo<T0>::to_string()
{
std::stringstream ss;
ss << m_Value;
return ss.str();
}

template <typename T0> std::string foo<T0>::to_string()
{
return typeid(T0).name();
}

Я видел это, однако я не знаю, как использовать код, я вообще не использовал enable_if и boost mpl. Как мне определить две функции to_string, чтобы использовать вторую как запасной вариант?

Благодарю.

Answer 1

Вы можете использовать boost:: has_left_shift

// Из документации

#include <boost/type_traits/has_left_shift.hpp>
#include <iostream>

template <class T>
struct contains { T data; };

template <class T>
bool operator<<(const contains<T> &lhs, const contains<T> &rhs) {
    return f(lhs.data, rhs.data);
}

class bad { };
class good { };
bool f(const good&, const good&) { }

int main() {
    std::cout<<std::boolalpha;
    // works fine for contains<good>
    std::cout<<boost::has_left_shift< contains< good > >::value<<'\n'; // true
    contains<good> g;
    g<<g; // ok
    // does not work for contains<bad>
    std::cout<<boost::has_left_shift< contains< bad > >::value<<'\n'; // true, should be false
    contains<bad> b;
    b<<b; // compile time error
    return 0;
}

Answer 2

Я возьму это на себя: вы можете взять метафункцию, которую вы нашли, как есть, она прекрасно работает. Давайте еще кратко обсудим, почему это работает:

sizeof на самом деле не оценивает выражение; он выводит свой тип и возвращает размер этого типа. Размеры типов определяются реализацией, и мы не можем много о них предполагать, но мы знаем, что sizeof(char) != sizeof(char[2])поэтому мы используем эти типы для проверки.

Мы определяем оператор потока на уровне пространства имен, используя any_t тип, который примет - как вы уже догадались - любой тип и позволит ему что-то вернуть (на самом деле не важно, какой тип, если это не так) ostream &). Это то, к чему мы возвращаемся, если для типа не определен оператор потока. В самом классе мы теперь определяем две функции, одна из которых принимает ostream &, который будет результатом, если определен оператор потока, а тот, который принимает тип возврата, который мы определили для нашей резервной функции.

Теперь мы можем проверить sizeof(test(s << c)) который, опять же, не будет оценивать выражение, только определит тип возвращаемого значения и вернет его размер.

Теперь все, что мы понимаем, как это работает, все, что осталось сделать, это встроить это в наше приложение. Есть несколько подходов, чтобы сделать это; Один из способов, который также работает до C++11, - использовать функтор:

template <bool, typename T>
struct to_string_functor
{
    std::string operator()(T const & t) const
    {
        std::stringstream ss;
        ss << t;
        return ss.str();
    }
};

template <typename T>
struct to_string_functor<false, T>
{
    std::string operator()(T const &) const
    {
        return typeid(T).name();
    }
};

template <typename T>
struct foo
{
    std::string to_string() const
    {
        return to_string_functor<
            has_insertion_operator<T>::value, T
        >()(m_Value);
    }
    /* ... */
};

Есть больше способов сделать это, другой способ enable_if, если C++11 доступен для вас (вам, вероятно, понадобятся частично специализированные функции для этого); Вы можете прочитать этот отличный пост в блоге по этому вопросу.

В этом простом случае, однако, функтор должен делать по моему мнению.

Answer 3

#include <iostream>
#include <sstream>
#include <typeinfo>

// has_insertion_operator
// ============================================================================

namespace has_insertion_operator_impl {
  typedef char no;
  typedef char yes[2];

  struct any_t {
    template<typename T> any_t( T const& );
  };

  no operator<<( std::ostream const&, any_t const& );

  yes& test( std::ostream& );
  no test( no );

  template<typename T>
  struct has_insertion_operator {
    static std::ostream &s;
    static T const &t;
    static bool const value = sizeof( test(s << t) ) == sizeof( yes );
  };
}

template<typename T>
struct has_insertion_operator :
  has_insertion_operator_impl::has_insertion_operator<T> {
};


// ToString
// ============================================================================

namespace Detail {
    template <typename T, bool>
    struct ToString {
        static std::string apply(const T& value)
        {
            std::stringstream s;
            s << value;
            return s.str();
        }
    };

    template <typename T>
    struct ToString<T, false> {
        static std::string apply(const T& value)
        {
            return typeid(T).name();
        }
    };
}

template <typename T>
inline std::string to_string(const T& value)
{
    return Detail::ToString<T, has_insertion_operator<T>::value>::apply(value);
}

has_insertion_operator был скопирован из связанного ответа Пола Лукаса в ( Использование SFINAE для проверки глобального оператора<).

Вы также можете использовать встроенное решение друга Майка Сеймура, показанное в ( Как неявно преобразовать что-либо в строку?). Я предпочитаю СФИНА, хотя.