Question

我刚刚遇到了一个奇怪的模糊性，这让我多年来一直孤立，因为它在一次小的API更改之后突然出现在模板混乱的中间。

以下示例探讨了调用构造函数的不同方法（或者我认为），其中一些对我来说非常模糊。在所有这些中，我试图声明一个A类型的对象。

#include <vector>
#include <cstdlib>
#include <iostream>
#include <typeinfo>
using namespace std;

// just a dummy class to use in the constructor of the next class
struct V {
   V(const std::vector<size_t> &){}
};

// the class we are interested in
struct A{
   A(const V &){}
   A(int, const V &){}
   A(const V &, int){}
   A(const V &, const V &){}
};

// a dummy function to delegate construction of V
V buildV(std::vector<size_t> &v){ return V(v); }

int main(){
   std::vector<size_t> v = {1024,1024};
   V vw(v);

   // I am using macros to make the constructor argument more visible
   #define BUILD_A(X) { A a(X); std::cerr << typeid(a).name() << std::endl; }
   #define BUILD_A2(X,Y) { A a(X, Y); std::cerr << typeid(a).name() << std::endl; }

   // All of the following call the constructor of A with different parameters
   // the comment on the right shows the type of the declared a
   /* 1 */ BUILD_A( vw )                       // object
   /* 2 */ BUILD_A( V(v) )                     // function pointer
   /* 3 */ BUILD_A( v )                        // object
   /* 4 */ BUILD_A( std::vector<size_t>() )    // function pointer
   /* 5 */ BUILD_A( (V)V(v) )                  // object
   /* 6 */ BUILD_A( ( V(v) ) )                 // object
   /* 7 */ BUILD_A( buildV(v) )                // object

   /* 8 */ BUILD_A2(10,V(v))                   // object
   /* 9 */ BUILD_A2(V(v),10)                   // object
   /* 10 */ BUILD_A2(vw,V(v))                  // object
   /* 11 */ BUILD_A2(V(v), vw)                 // object

   /* 12 */ //BUILD_A2(V(v), V(v))             // doesn't compile
   /* 13 */ BUILD_A2(V(v), (V)V(v))            // object
}

第二个和第四个例子似乎声明了一个函数指针而不是一个对象，这引发了一些问题：

为什么V(v)被解释为类型而不是A a(V(v))的对象？
如何以V(v)对(V)V(v)进行不同的解释？
为什么编译器无法推断出演员本身？
6中的双括号((...))是否具有语义含义，还是仅仅有助于消除解析器的歧义？我不知道它可能是一个优先问题。
如果V(v)评估为Type而不是对象，为什么A a(V(v), V(v))在12中不合法？
有趣的是，添加标量值也会突然使编译器在8到11之间实现另一个对象。
我是否遗漏了任何可以重现模糊性的语法？你知道其他任何令人困惑的案件吗？
海湾合作委员会不应该警告我那里可能有问题吗？ Clang确实。

谢谢，

Answer 1

这被称为最令人烦恼的解析：尝试的声明被解析为函数声明。

C ++规则是，如果可以将某些东西解析为函数声明，那么它将是。

有一些解决方法，例如编写A a(( V(v) ))，这些解决方法无法解析为带有a参数的函数V的声明并返回A。

关于警告，该标准不需要任何诊断。毕竟，潜在的歧义已经解决。赞成功能。： - ）

构造函数调用作为构造函数参数将声明评估为函数指针

1 个答案: