Is most vexing parse a formally defined concept

by

is the concept of “most vexing parse” formally defined by the C++ standard.

No. There is no concept of “most vexing parse” defined in the C++ standard. The standard does define the grammar from which the ambiguities arise, and it defines the rule that resolves the ambiguities, but it doesn’t name the ambiguities.

According to Wikipedia: “The term “most vexing parse” was first used by Scott Meyers in his 2001 book Effective STL.”. The example in the book is:

Item 6. Be alert for C++’s most vexing parse.

ifstream dataFile("ints.dat");
list<int> data(istream_iterator<int>(dataFile), // warning! this doesn't do
               istream_iterator<int>());        // what you think it does

The way I would describe “MVP” is that there is an intention to declare a variable, with passed argument(s), but you end up actually writing a function declaration and the intended arguments turn out as parameter declarators.

does the statement ArrTest ar(); uses most vexing parse.

The book explicitly mentions this ambiguity as well:

If you’ve been programming in C++ for a while, you’ve almost certainly encountered another manifestation of this rule. How many times have you seen this mistake?

class Widget {...}; // assume Widget has a default constructor
Widget w();         //'uh oh...

Given that the author who came up with the name for the ambiguity considers this as another manifestation – as opposed to the same manifestation – of a language rule, I would say that the example in question is not the “MVP”. It’s another, similar, and in my opinion less vexing ambiguity.

More Related Contents:

  1. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  2. Default constructor with empty brackets
  3. What is the purpose of the Most Vexing Parse?
  4. What happens if you static_cast invalid value to enum class?
  5. Will std::string always be null-terminated in C++11?
  6. Is the compiler allowed to optimize out heap memory allocations?
  7. Difference between Undefined Behavior and Ill-formed, no diagnostic message required
  8. Is passing a C++ object into its own constructor legal?
  9. Is it legal to compare dangling pointers?
  10. Why is “using namespace X;” not allowed at class/struct level?
  11. Does a declaration using “auto” match an extern declaration that uses a concrete type specifier?
  12. std::ignore with structured bindings?
  13. So why is i = ++i + 1 well-defined in C++11?
  14. Why is it not possible to overload class templates?
  15. treating memory returned by operator new(sizeof(T) * N) as an array
  16. Is circumventing a class’ constructor legal or does it result in undefined behaviour?
  17. Static member access in constant expressions
  18. Why is f(i = -1, i = -1) undefined behavior?
  19. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  20. Why does `int ;` compile fine in C, but not in C++?
  21. What happened to the “aggregate or union type that includes one of the aforementioned types” strict aliasing rule?
  22. Can I Reference Previous Members of an Initializer List?
  23. When do extra parentheses have an effect, other than on operator precedence?
  24. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  25. Is reinterpret_cast type punning actually undefined behavior?
  26. Familiar template syntax for generic lambdas
  27. reinterpret_cast between char* and std::uint8_t* – safe?
  28. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  29. Will I be able to declare a constexpr lambda inside a template parameter?
  30. C++11 cross compiler/standard library random distribution reproducibility

Leave a Comment