Default Constructor With Empty Brackets

Default constructor with empty brackets

Most vexing parse

This is related to what is known as "C++'s most vexing parse". Basically, anything that can be interpreted by the compiler as a function declaration will be interpreted as a function declaration.

Another instance of the same problem:

std::ifstream ifs("file.txt");
std::vector<T> v(std::istream_iterator<T>(ifs), std::istream_iterator<T>());

v is interpreted as a declaration of function with 2 parameters.

The workaround is to add another pair of parentheses:

std::vector<T> v((std::istream_iterator<T>(ifs)), std::istream_iterator<T>());

Or, if you have C++11 and list-initialization (also known as uniform initialization) available:

std::vector<T> v{std::istream_iterator<T>{ifs}, std::istream_iterator<T>{}};

With this, there is no way it could be interpreted as a function declaration.

Default Constructor with Empty Brackets C++ Error

You need to place member function definitions (including constructor definitions) in the same header where the template class is defined.

As for this statement

// here i create Vector v, if i put Vector<int> v() i don't get error
Vector<int> v();

then it is a function declaration that has return type Vector<int> and does not have parameters. It is not a definition of an object of type Vector<int>.

What happens when I try to create an object using its empty default constructor but while adding brackets in ANSI C++? [duplicate]

When you write this:

int foo();

…it declares a function called foo that returns an int.

When you write this:

Complex c1();

…it declares a function called c1 that returns a Complex.

Lose the ().

Contrary to popular belief, this is not quite "the most vexing parse", but it is close.

how to determine the constructor which called with empty braced initializer?

I could not determine how the object w2 is constructed.

w2 is constructed by the default constructor; as you can see from the output

0 Widget()

Firstly, Widget is not an aggregate type, it has user-defined constructors; then Widget w2{}; performs value initialization.

In all cases, if the empty pair of braces {} is used and T is an
aggregate type, aggregate-initialization is performed instead of
value-initialization.

If T is a class type that has no default constructor but has a
constructor taking std::initializer_list, list-initialization is
performed.

Both above cases are false here. Then

1) if T is a class type with no default constructor or with a user-provided or deleted default constructor, the object is default-initialized;

then in default initialization,

(emphasis mine)

if T is a non-POD (until C++11) class type, the constructors are considered and subjected to overload resolution against the empty argument list. The constructor selected (which is one of the default constructors) is called to provide the initial value for the new object;

BTW: Widget w1(); is not a variable definition, but a function declaration; which declares a function named w1 taking nothing and returning Widget. That's why you only get 3 outputs. You might want Widget w1;.

Does curly brackets matter for empty constructor? [duplicate]

They're not same. {} represents a regular function-body and makes the former function definition.

foo(void){}; // function definition
foo(void);   // function declaration

What do empty braces mean in struct declaration?

What do empty brackets mean in struct declaration?

T object {}; is syntax for value initialization (4). Without the curly brackets, the object would be default initialized.

To be pedantic, this is not a "struct declaration". It is declaration of a variable.

when I go to value initialization, I can't figure out which, if any, of the cases apply.

This one applies:

2) if T is a class type with a default constructor that is neither user-provided nor deleted (that is, it may be a class with an implicitly-defined or defaulted default constructor), the object is zero-initialized and then it is default-initialized if it has a non-trivial default constructor; (since C++11)

And that is how we get to zero initialization. Your interpretation of the zero initialization rules is correct.

I'm wondering if this behavior is actually defined in the specs

The rules in the linked pages are based on the standard, not on a specific implementation. The behaviour is defined.

Why does a Member initialized list for a default constructor in a composite class not call the member object constructor? [duplicate]

test2 b(); is a function declaration, not a variable declaration. It declares a function named b that takes no arguments and returns a test2. Either of the following would produce a test2 variable that uses the default constructor:

int main(){
    test2 b; // No parentheses at all
}

int main(){
    test2 b{}; // Curly braces instead of parentheses
}