如何在 C++17 中将模板打印到控制台？

Question

我有这个基本模板类：

template<typename Type>
struct InputBase {
    virtual void DisplaySingleResult(Type const& res) const {
        std::cout << res << std::endl;
    }
};

因此，下面的代码无法编译，因为vector没有<<运算符

struct Input : InputBase<std::vector<std::vector<int>>> {
    void DisplaySingleResult(std::vector<std::vector<int>> const& results) const override {
        for (std::vector<int> const& result : results) {
            std::cout << "[" << result[0] << "," << result[1] << "]";
        }
        std::cout << std::endl;
    }
};

编译时，方法InputBase::DisplaySingleResult编译失败，因为它使用vector类型。

一种解决方法是使虚拟InputBase::DisplaySingleResult方法纯虚拟。

但是，我希望在我的基类中有一个具有相同签名的DisplaySingleResult方法，以避免重写所有其他派生类。 如何在 C++17 中做到这一点？

解决方案暂定：在InputBase::DisplaySingleResult中，使用前检查模板 Type 是否有<<运算符。

Answer 1

我不建议直接为std::ostream& operator<<(std::ostream&,const std::vector<T>&)提供重载（不确定是否允许）。 而是间接的。

而不是调用std::cout << res << std::endl; 你可以调用一个函数：

template<typename Type>
void print_result(const Type& res) { std::cout << res << std::endl; }

template<typename Type>
struct InputBase {
    virtual void DisplaySingleResult(Type const& res) const {
        print_result(res);
    }
};

现在您可以为没有operator<<的任何类型提供重载，例如

void print_result(const std::vector<int>& v) { for (const auto& e : v) print_result(e); } 

为了更灵活地使用专业化，您可能需要考虑将print_result类模板而不是函数模板。 例如，当T具有begin()和end()时，可能会有一个专门化元素调用print_result 。

Answer 2

如果适当地支持该类型，您可以在编译时进行测试：

1. 如果已经有合适的输出运算符可用，请使用它（如果可以直接输出类型，则此测试可确保您不使用迭代器，例如std::string ）。
2. 否则，如果类型具有begin和end功能，则使用这些。
3. 否则我们将处于错误状态！

这可能如下所示：

template<typename Type>
struct InputBase
{
    static void displaySingleResult(Type const& res)
    {
        if constexpr (decltype(has_operator_out(res))::value)
        {
            std::cout << res;
        }
        else if constexpr
        (
            decltype(has_begin(res))::value && decltype(has_end(res))::value
        )
        {
            // your own desired formatting, e.g.:
            std::cout << '[';
            for(auto& r : res)
            {
                std::cout << r << ' ';
            }
            std::cout << ']';
        }
        else
        {
            // error handling:
            std::cout << "<invalid!>";
        }
    }

private:
    template <typename T>
    static auto has_operator_out(T& t)
        -> decltype(std::cout << t, std::true_type());
    static std::false_type has_operator_out(...);
    template <typename T>
    static auto has_begin(T& t)
        -> decltype(t.begin(), std::true_type());
    static std::false_type has_begin(...);
    template <typename T>
    static auto has_end(T& t)
        -> decltype(t.end(), std::true_type());
    static std::false_type has_end(...);
};

相反，递归调用该函数也允许打印嵌套容器（感谢463035818_is_not_a_number的提示）：

std::cout << '[';
for(auto& r : res)
{
    InputBase<std::remove_cv_t<std::remove_reference_t<decltype(r)>>>
        ::displaySingleResult(r);
    std::cout << ' ';
}
std::cout << ']';

注意：

1. ...该功能可以是static的，因为this不在任何地方使用。
2. ...定义一个operator<<会更像 C++。
3. ...您可以提供进一步的测试或根据您的需要调整现有的测试，例如使用std::begin和std::end代替。
4. ...这些测试还有其他可能的模式，您可能想玩一下；）

Answer 3

如果您需要DisplaySingleResult()是虚拟的，典型的方法是委托给一个非虚拟函数，它可以是一个模板：

virtual void DisplaySingleResult(Type const& res)
{
    DisplaySingleResultImpl(res);
}

然后你可以模板化DisplaySingleResultImpl() 。 现在，在许多情况下，您不想在基类中执行此操作（或只想提供典型的实现）——在这些情况下，会想到 CRTP：

template<typename Type, typename Derived>
struct InputBase {
    virtual void DisplaySingleResult(Type const& res) const {
        static cast<const Derived&>(*this).DisplaySingleResultImpl(res);
    }
};

template<typename Type, typename Derived>
struct InputBaseWithCoutPrint : InputBase<Type, Derived> {
    void DisplaySingleResultImpl(Type const& res) const {
        std::cout << res << std::endl;
    }
};

CRTP 是一个非常强大的工具，不要过度使用它。