c++ - 是否有一种优雅的解决方案来区分模板成员函数调用中的 void 和非 void 参数？

Question

有一个基类及其对 void 的特化:

#include  <iostream>
template <typename T>
struct Base
{
    typedef T result_type;
    result_type get_value() { return result_type(); }
    void process_value(result_type&&) {
        std::cout << "type\n";
    }
};

template <>
struct Base<void>
{
    typedef void result_type;
    void get_value() {};
    void process_value(/*void&&*/) {
        std::cout << "void\n";
    }
};

template <typename T>
struct Derived : Base<T>
{
    typedef typename Base<T>::result_type result_type;
    // Returning void from a function call is fine.
    result_type get() { return this->get_value(); }
    void invoke() {
        // If T is void: error: invalid use of void expression
        this->process_value(get());
    }
};

int main() {
    Derived<int>().invoke();
    // Trigger a compilation faluure:
    Derived<void>().invoke();
}

是否有一个优雅的解决方案来区分“process_value”调用中的 void 和非 void 参数(C++11 可以)？

Answer 1

在将结果作为参数传递时，一种方法是用一些空类代替 void。我觉得它不是很优雅，但它确实有效:

#include  <iostream>
template <typename T>
struct Base
{
    typedef T result_type;
    result_type eval() { return result_type(); }
    result_type get_value() { return result_type(); }
    void process_value(result_type&&) {
        std::cout << "type\n";
    }
};

template <>
struct Base<void>
{
    struct value_type { };
    typedef void result_type;
    value_type eval() { return value_type{}; }
    void get_value() {};
    void process_value(value_type) {
        std::cout << "void\n";
    }
};

template <typename T>
struct Derived : Base<T>
{
    typedef typename Base<T>::result_type result_type;
    result_type get() { return this->get_value(); }
    void invoke() {
        this->process_value(this->eval());
    }
};

int main() {
    Derived<int>().invoke();
    Derived<void>().invoke();
}

为了找到更优雅的东西，我觉得你可能需要重构你原来的问题。