1

我刚刚遇到了一个奇怪的歧义，我花了很长时间才将其隔离出来，因为它在一个小的 API 更改后突然出现在一些模板混乱的中间。

下面的示例探讨了调用构造函数的不同方法（或者我认为），其中一些对我来说非常模糊。在所有这些中，我都试图声明一个 type 的对象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
}

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

  1. 为什么被V(v)解释为类型而不是对象A a(V(v))？
  2. 如何以不同的方式重新V(v)转换(V)V(v)？
  3. 为什么编译器无法推断强制转换本身？
  4. 6中的双括号是否((...))具有语义意义，还是只是有助于消除解析器的歧义？我不明白这怎么可能是一个优先问题。
  5. 如果V(v)评估为类型而不是对象，为什么A a(V(v), V(v))在 12 中不合法？
  6. 有趣的是，添加一个标量值也会突然让编译器意识到另一个也是 8 到 11 中的对象。
  7. 我是否错过了任何会重现歧义的语法？你知道其他令人困惑的案例吗？
  8. GCC 不应该警告我那里可能有问题吗？铿锵声。

谢谢，

4

1 回答 1

1

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

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

有一些变通方法，例如 write A a(( V(v) ))，它不能被解析为a带有V参数和返回的函数的声明A。

关于警告，该标准不需要对此进行任何诊断。毕竟，潜在的歧义已经解决。有利于功能。:-)

于 2013-04-11T18:52:09.267 回答