如何在C＆＃x2B;＆＃x2B; 17中打印一个模板以控制？

Question

我有此基本模板类：

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

因此，下面的代码不会编译，因为 vector 没有＆lt;＆lt;＆lt; 运算符

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 type。

解决方法是使虚拟 inputBase :: displaysingleresult 方法纯虚拟。

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

解决方案试验： inputbase :: displaysingleresult ，检查模板类型是否具有＆lt;＆lt;＆lt; 运算符。

Answer 1

我不建议为 std :: Ostream＆amp;提供超载。操作员＆lt;＆lt;（std :: ostream＆amp;，const std :: vector＆lt; t＆gt;＆amp;＆amp;）直接（不确定是否允许它）。但是间接。

而不是调用 std :: Cout＆lt;＆lt; res＆lt;＆lt; 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);
    }
};

现在您可以为没有运算符＆lt;＆lt;＆lt; 提供

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

超载要考虑制作 print_result 类模板而不是函数模板。例如，当 t 具有 begin> begin（） and end（end eend（） end（）。

Answer 2

您可以在编译时测试是否适当支持类型：

1. 如果有合适的输出操作员已经使用它（此测试可以确保您不使用迭代器，如果类型可以直接输出，例如，例如 std :: String ）。
2. 否则，如果类型具有开始和结束函数使用这些功能。
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(...);
};

递归调用该功能也允许打印嵌套容器（感谢对于提示）：

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

请注意：

1. ... <代码>静态 在任何地方都不使用此。
2. ...定义运算符＆lt;＆lt; 更喜欢C ++。
3. ...您可能会提供进一步的测试或根据您的需求调整现有测试，例如使用 std :: begin 和 std :: end end 而不是使用。
4. ...对于这些测试还有其他模式，您可能想与之一起玩；）

Answer 3

如果您需要具有 displaysingleresult（）是虚拟的，那么一种典型的方法是委派给非虚拟函数，这可以是模板：

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

那么您可以templetize 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是一个非常强大的工具，不要过度使用它。