C++ 0/1 参数构造函数在传递给模板构造函数时未按预期链接

Question

在下面的代码示例中，我有一个 class 和一个模板化的单参数构造函数，称为 Acceptor1。我想将 Foo, Bar, or Baz 类型的对象传递给它的构造函数，链接构造函数调用。 （事实是这个简化的例子反映了我试图用类型擦除做的事情：我想将一个对象传递给橡皮擦 class。） 实际发生了什么是当我尝试声明一个 Acceptor1 对象并传递它时，例如Foo 对象，我定义了一个指向函数的变量，该函数接受 FUNCTION 指针（不是 Foo 对象）和 returns Acceptor1。函数指针的类型是Foo(*)()。全局变量声明为 Acceptor1 (Foo (*)()).

类型

我无法使用任何可能的 enable_if 语句来解决这个问题，如 Accessor2 class 示例所示，我什至没有 define 1 参数构造函数。

就像我提到的，它的最终用途是能够拥有一个类型擦除器 class，它有一个看起来像 Acceptor1 的构造函数，加上额外的类型擦除机制。我已经这样做了，只要我擦除的类型不是用 0/1 参数构造函数构造的，它就可以正常工作。或者，我可以在两个单独的语句中声明和分配变量。但是，我有很多，这会使代码的大小增加一倍，我猜还要多占用几个 CPU 个周期。

有没有人知道如何将 Acceptor1 test( Foo() ) 视为定义 Accessor1，并使用 Foo 对象对其进行初始化？它适用于 Accessor1 test( Baz(d, d2) )，一种有两个参数的情况。它也适用于文字，例如Acceptor1 test( Bar(1.0) )。谢谢！

肖恩

代码如下：

#include <iostream>
#include <typeinfo>

using namespace std;

struct Foo {
    Foo() {
        cout << "Foo" << endl;
    }
};

struct Bar {
    Bar(double a) {
        cout << "Bar" << endl;
    }
};

struct Baz {
    Baz(double a, double b) {
        cout << "Baz" << endl;
    }
};

struct Acceptor1 {
    template<typename T> //no possible enable_if could help this problem
    Acceptor1(T f) {
        cout << typeid(T).name() << endl;
    }
};

struct Acceptor2 {
};

int main()
{
    double d, d2;

    std::cout << std::endl;

    //0 arguments - captures a conversion constructor
    Acceptor1 one(Foo()); //F9Acceptor1PF3FoovEE=Acceptor1 (Foo (*)())
    cout << "one: " << typeid(one).name() << endl << endl;
    
    //0 arguments - the result we expect
    Acceptor1 two = Acceptor1(Foo()); //9Acceptor1=Acceptor1
    cout << "two: " << typeid(two).name() << endl << endl;

    //There's no possible way to enable_if it out - I deleted the whole constructor
    Acceptor2 three(Foo()); //F9Acceptor2PF3FoovEE=Acceptor2 (Foo (*)())
    cout << "three: " << typeid(three).name() << endl << endl;

    //1 arguments - captures a conversion constructor
    Acceptor1 four(Bar(d)); //F9Acceptor13BarE=Acceptor1 (Bar)
    cout << "four: " << typeid(four).name() << endl << endl;
    
    //1 arguments - the result we expect
    Acceptor1 five = Acceptor1(Bar(d)); //9Acceptor1=Acceptor1
    cout << "five: " << typeid(five).name() << endl << endl;

    //There's no possible way to enable_if it out - I deleted the whole constructor
    Acceptor2 six(Bar(d)); //F9Acceptor23BarE=Acceptor2 (Bar)
    cout << "six: " << typeid(six).name() << endl << endl;

    //1 arguments - literal
    Acceptor1 seven(Bar(5.0)); //9Acceptor1=Acceptor1
    cout << "seven: " << typeid(seven).name() << endl << endl;

    //2 arguments - the result we expect
    Acceptor1 eight(Baz(d, d2)); //9Acceptor1=Acceptor1
    cout << "eight: " << typeid(eight).name() << endl << endl;
    
    //2 arguments - the result we expect
    Acceptor1 nine = Acceptor1(Baz(d, d2)); //9Acceptor1=Acceptor1
    cout << "nine: " << typeid(nine).name() << endl << endl;

    using FooMaker = Foo(&)();
    using AcceptorFnToBazMaker = Acceptor1(*)(FooMaker); //PF9Acceptor1RF3FoovEE=Acceptor1 (*)(Foo (&)())
    cout << "AcceptorFnToBazMaker: " << typeid(AcceptorFnToBazMaker).name() << endl << endl;

    return 0;
}

编辑：有人建议这是 Default constructor with empty brackets 的副本 - 我同意他们都提到“最令人烦恼的解析”作为问题的根源，但问题是不同的。那里的答案甚至包括一个具有 2 个参数的函数的示例。在我的例子中，对于构造函数，只有 0/1 参数的构造函数被特殊对待。

Answer 1

将 Acceptor1 test( Foo() ) 更改为 Acceptor1 test((Foo())) 或者更好的方法是 Acceptor1 test{Foo()} 或者（就像您所做的那样）Acceptor1 test = Acceptor1(Foo());

编译器可以将该行解释为有效的函数声明和对象初始化。标准（据我所知）说在这种情况下，将其作为函数声明。这是 in cppreference about this :

In case of ambiguity between a variable declaration using the direct-initialization syntax (1) (with round parentheses) and a function declaration, the compiler always chooses function declaration. This disambiguation rule is sometimes counter-intuitive and has been called the most vexing parse.

因此你得到了这个。

要使编译器将其解释为对象初始化，请添加括号 () 使其成为无效的函数声明。即，您所要做的就是确保它不是有效的函数声明语法。

C++ 0/1 参数构造函数在传递给模板构造函数时未按预期链接

C++ 0/1-argument constructors not chaining as expected when passed to template constructor

c++

templates

constructor-overloading

type-erasure

template-argument-deduction