c++ - 模板元编程 - 确定函数参数

Question

template<bool, class T, class U> 
struct IF_ELSE { using type = T; };

template<class T, class U>
struct IF_ELSE<false, T, Y> { using type = U; }

template<class T>
class Object { 

  Object baz(IF_ELSE<boolean_condition<T>::value, foo_class, bar_class>::type param) {

       return Object(param);
   }
};

你好，我正在尝试创建一个方法，该方法返回一个根据某些模板条件初始化的对象。上面的代码工作正常但是我想使用默认构造函数(无参数)

template<class T>
class Object { 

  Object baz(IF_ELSE<boolean_condition<T>::value, foo_class, void>::type param) {

       return Object(param);
   }
};

然而，不可能将 void 用作类型(尽管 void foo(void); 是一个有效的声明)

有什么办法吗？

注释。我不想使用模板特化。虽然这是针对这个特定问题的解决方案，但在我当前的项目中简单地使用特化是不方便的。我个人更喜欢使用 IF_ELSE 而不是特化，因为我发现它更容易理解。

我能想到的唯一解决方法是...

template<class T>
class Object { 

  Object baz(IF_ELSE<boolean_condition<T>::value, foo_class, int>::type param = 0) {
        if (param == 0)
       return Object();
        else 
       return Object(param);

   }
};

如果有人有更复杂的解决方案那就太好了。非常感谢。

--------------------------------编辑------------ ------------------

这个解决方法更好一些(受 Oisyn 启发)，它或多或少结合了参数特化和默认参数这两个世界的优点。可能也快一点，因为它避开了 if 语句。

template<class T>
class Object
{

public:
struct MAKE_ILLEGAL {};

template<class param>
Object(param p) {/*do stuff */}
Object() {/* default */ }


template<bool b>
Object<T> baz(std::conditional_t<b, int, MAKE_ILLEGAL> param)
{ return Object<T>(param); }

template<bool b>
Object<T> baz(std::conditional_t<b, MAKE_ILLEGAL, int> value = 0)
{ return Object<T>(); }
};

int main() {

    Object<double> obj;
    obj.baz<false>();
}

Answer 1

编辑 显然你不能使用解析为 void 的东西作为类型相关上下文中的函数参数。我已经使用不同的解决方案相应地编辑了我的答案。原始答案可以在下面阅读。

// A helper that always yields true so we can make the condition type-dependent
// on arbitrary template parameters
template<class T>
constexpr bool true_v = true;

template<class T>
class Object
{
public:
    template<class U = void, std::enable_if_t<Condition<T>::value && true_v<U>, int> = 0>
    Object baz(foo_class param)
    { return Object(param); }

    template<class U = void, std::enable_if_t<!Condition<T>::value && true_v<U>, int> = 0>
    Object baz()
    { return Object(); }
};

只要我们不处理复制/移动构造函数和复制/移动赋值运算符(可能未模板化)等特殊方法，我们始终可以应用常规 SFINAE 技巧。我们只需要模板化 baz使用默认模板参数，并确保用于 std::enable_if 的条件类型依赖于该方法的模板参数(并且不仅仅依赖于 T 中的 Object<T>)

Live version

---

原始答案

template<class T>
class Object
{
private:
    struct dummy { };

public:
    Object baz(std::conditional_t<Conditional<T>::value, foo_class, dummy> param)
    { return Object(param); }

    Object baz(std::conditional_t<Conditional<T>::value, dummy, void>)
    { return Object(); }
};

想法是您创建两个重载，一个用于单个参数，一个用于无参数。通过有选择地用不可访问的虚拟类型替换参数，您可以确保永远无法在不合适的时候调用该重载。