标签: most-vexing-parse

class foo {
    public:
    bool operator () (int & i) {
        return true;
    }
};

int main() {
    foo(WhyDoesThisCompile);
    return 0;
}

当传递WhyDoesThisCompile(没有空格)到仿函数时,程序编译.

为什么是这样？我在clang 4.0.0上测试过它.

在查看一些C++ 03代码时,我发现了一个让我感到困惑的最令人烦恼的解析实例:

#include <sstream>
#include <string>

int main(int, char** argv)
{
    std::stringstream ss(std::string(argv[0]));
}

wandbox上的实例

在上面的代码片段中,ss是一个函数的声明,它接受std::string*并返回std::stringstream.

怎么std::string(argv[0])解析为std::string*？

直觉上,我认为这argv[0]是明确无误的访问argv.

此代码的行为与我的预期不符.

#include<iostream>
using namespace std;

class Class
{
    Class()
    {
        cout<<"default constructor called";
    }

    ~Class()
    {
        cout<<"destrutor called";
    }
};

int main()
{    
    Class object();
}

我期望输出'默认构造函数',但我没有看到任何输出.问题是什么？

我正在阅读一篇 SO 帖子，其中一位用户发表了以下评论：

另请注意，ArrTest<int> ar();使用了最令人烦恼的 parse。

但另一位用户却表示相反：

ArrTest<int> ar();不是“最令人烦恼的解析”。这只是一个函数声明。对于初学者来说这当然很麻烦，但是，正如您链接到的页面所示，“最令人烦恼的解析”更加复杂。

下面给出了该帖子中的代码示例以供参考：

template <class ItemType>
class ArrTest {
public:
    ArrTest();
private:
    ItemType* info;
};
//some other code here

int main() {
    ArrTest<int> ar();  //DOES THIS USE THE MOST VEXING PARSE?
    return 0;
}

我的第一个问题是 C++ 标准正式定义的“最令人烦恼的解析”的概念。我的第二个问题是该语句是否ArrTest<int> ar();使用了最令人烦恼的解析。也就是说，上面引用的两条评论哪一条在技术上是正确的？

这似乎也表明这MyObject object();是最令人烦恼的解析。

我刚遇到这个问题

error: request for member ‘show’ in ‘myWindow’, which is of non-class type ‘MainGUIWindow()’

当试图编译一个简单的qt应用程序时:

#include <QApplication>
#include "gui/MainGUIWindow.h"


int main( int argc, char** argv )
{
  QApplication app( argc, argv );


  MainGUIWindow myWindow();
  myWindow.show();


  return app.exec();
}

我通过替换解决了这个问题

MainGUIWindow myWindow(); 

通过

MainGUIWindow myWindow;

但我不明白其中的区别.我的问题:有什么区别？

此致,德克

今天在工作中我遇到了一个我不懂的C++行为.我已经生成了以下示例代码来说明我的问题:

#include <string>
#include <iostream>

class MyException
{
    public:
        MyException(std::string s1) {std::cout << "MyException constructor, s1: " << s1 << std::endl;}
};

int main(){
    const char * text = "exception text";
    std::cout << "Creating MyException object using std::string(const char *)." << std::endl;
    MyException my_ex(std::string(text));
    std::cout << "MyException object created." << std::endl;
    //throw my_ex;

    std::string string_text("exception text");
    std::cout << "Creating MyException object using std::string." << std::endl;
    MyException my_ex2(string_text);
    std::cout << "MyException object created." << std::endl;
    // throw my_ex2;

    return 0;
} …

在下面的代码中,为什么编译器不抱怨mClass2？

class CMyClass{
private:
    CMyClass(){}
};

void TestMethod(){
    CMyClass mClass1;   //Fails.
    CMyClass mClass2(); //Works.
}

我的问题是如何将以下行解析为函数声明:

vector<int> v(istream_iterator<int>(cin), istream_iterator<int>());

我理解Most Vexing Parse的大部分细节以及为什么第二个临时迭代器可以被解释为一个返回迭代器并且不带参数的函数的类型,但是我没有得到的是为什么第一个临时迭代器可以是解释为一种类型.它代表什么类型？我的想法是它会是某种函数类型,但我看不出名称是如何cin被使用的.它是否声明该参数是一个istream_iterator<int>名为cin？如果是这样,这是否意味着您可以任意地将函数的参数名称括起来？如果是这样,为什么？

我遇到了一个我甚至不知道如何描述的编译错误!这完全让我感到困惑.

情况:

代码尝试使用用char*初始化的rvalue std :: string在堆栈上创建一个对象.

代码:

#include <iostream>
#include <string>

class Foo
{
    public:
        Foo(double d)
            : mD(d)
        {
        }

        Foo(const std::string& str)
        {
            try
            {
                mD = std::stod(str);
            }
            catch (...)
            {
                throw;
            }
        }

        Foo(const Foo& other)
            : mD(other.mD)
        {
        }

        virtual ~Foo() {}

    protected:
        double mD;
};

class Bar
{
    public:
        Bar(const Foo& a, const Foo& b)
            : mA(a)
            , mB(b)
        {
        }

        virtual ~Bar() {}

    protected:
        Foo mA;
        Foo mB;
};

int main(int …

阅读了最令人烦恼的解析后,我进行了一些实验并找到了这个程序.有两条非常相似的线.其中一个在g ++ 7和clang ++ - 3.9中产生警告,另一个则没有.

int main() {
  void(); // no warning
  int(); // warning: statement has no effect
}

在第二行中,创建了一个默认构造的类型对象int并立即销毁,因此未使用.但是第一行会发生什么？如果以相同的方式解析它,则应该是错误,因为创建类型的对象是非法的void.另一方面,它看起来也不像函数声明.