Why class data members can’t be initialized by direct initialization syntax?

by

Early proposals leading to the feature’s introduction explain that this is to avoid parsing problems.

Here’s just one of the examples presented therein:

Unfortunately, this makes initializers of the “( expression-list )” form ambiguous at the time that the declaration is being parsed:

struct S {
    int i(x); // data member with initializer
    // ...
    static int x;
};

struct T {
    int i(x); // member function declaration
    // ...
    typedef int x;
};

One possible solution is to rely on the existing rule that, if a declaration could be an object or a function, then it’s a function:

struct S {
    int i(j); // ill-formed...parsed as a member function,
              // type j looked up but not found
    // ...
    static int j;
};

A similar solution would be to apply another existing rule, currently used only in templates, that if T could be a type or something else, then it’s something else; and we can use “typename” if we really mean a type:

struct S {
    int i(x); // unabmiguously a data member
    int j(typename y); // unabmiguously a member function
};

Both of those solutions introduce subtleties that are likely to be misunderstood by many users (as evidenced by the many questions on comp.lang.c++ about why “int i();” at block scope doesn’t declare a default-initialized int).

The solution proposed in this paper is to allow only initializers of the “= initializer-clause” and “{ initializer-list }” forms. That solves the ambiguity problem in most cases. [..]

More Related Contents:

  1. Does initialization entail lvalue-to-rvalue conversion? Is `int x = x;` UB?
  2. What’s the behavior of an uninitialized variable used as its own initializer?
  3. Will std::string always be null-terminated in C++11?
  4. static initialization order fiasco
  5. How to initialise memory with new operator in C++?
  6. Sequence points and partial order
  7. C++11: Correct std::array initialization?
  8. Is the behaviour of i = i++ really undefined?
  9. About binding a const reference to a sub-object of a temporary
  10. Explicit specialization in non-namespace scope does not compile in GCC
  11. Aliasing T* with char* is allowed. Is it also allowed the other way around?
  12. Is it legal to compare dangling pointers?
  13. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  14. Now that we have std::array what uses are left for C-style arrays?
  15. Why is “using namespace X;” not allowed at class/struct level?
  16. Does a declaration using “auto” match an extern declaration that uses a concrete type specifier?
  17. C++: Where to initialize variables in constructor [duplicate]
  18. Does this really break strict-aliasing rules?
  19. So why is i = ++i + 1 well-defined in C++11?
  20. When do extra parentheses have an effect, other than on operator precedence?
  21. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  22. Different ways of initializing an object in c++
  23. How could comma separated initialization such as in Eigen be possibly implemented in C++?
  24. Is there some meaningful statistical data to justify keeping signed integer arithmetic overflow undefined?
  25. Is it a strict aliasing violation to alias a struct as its first member?
  26. Is uninitialized data behavior well specified?
  27. C++ function called without object initialization
  28. What is the modern, correct way to do type punning in C++?
  29. Overload resolution with ref-qualifiers
  30. Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?

Leave a Comment