Mrthfx

What is the difference between

std::vector<int> v;

and

std::vector<int> v = std::vector<int>();

Intuitively, I would never use the second version but I am not sure there much difference. It feels to me that the second line is simply a default constructor followed by a move assignment operator but I am really not sure.

I am wondering whether the second line is not somehow equivalent to

std::vector<int>* p = new std::vector<int>();

std::vector<int> v = *p;

or

std::vector<int> v3 = *(new std::vector<int>()); 

hence causing the vector itself to be on the heap (dynamically allocated). If it is the case, then the first line would probably be preferred.

How do these lines of code differ?

The 1st one is default initialization, the 2nd one is copy initialization; The effect is same here, i.e. initialize the object v via the default constructor of std::vector.

For std::vector<int> v = std::vector<int>();, in concept it will construct a temporary std::vector then use it to move-construct the object v (note there's no assignment here). According to the copy elision (from C++17 it's guaranteed), it'll just call the default constructor to initialize v directly.

Under the following circumstances, the compilers are required to omit
the copy and move construction of class objects, even if the copy/move
constructor and the destructor have observable side-effects. The
objects are constructed directly into the storage where they would
otherwise be copied/moved to. The copy/move constructors need not be
present or accessible, as the language rules ensure that no copy/move
operation takes place, even conceptually:

• 
  

  In the initialization of a variable, when the initializer expression
  is a prvalue of the same class type (ignoring cv-qualification) as the
  variable type:

  
  
  

  T x = T(T(f())); // only one call to default constructor of T, to initialize x
  
  

  
  

BTW: For both cases, no std::vector objects (including potential temporary) will be constructed with dynamic storage duration via new expression.

Starting from C++17 there's no difference whatsoever.

There's one niche case where the std::vector = std::vector initialization syntax is quite useful (albeit not for default construction): when one wants to supply a "count, value" initializer for std::vector<int> member of a class directly in the class's definition:

struct S {

  std::vector<int> v; // Want to supply `(5, 42)` initializer here. How?

};

In-class initializers support only = or {} syntax, meaning that we cannot just say

struct S {

  std::vector<int> v(5, 42); // Error

};

If we use

struct S {

  std::vector<int> v{ 5, 42 }; // or = { 5, 42 }

};

the compiler will interpret it as a list of values instead of "count, value" pair, which is not what we want.

So, the proper way to do it is

struct S {

  std::vector<int> v = std::vector(5, 42);

};

You had asked:

What is the difference between

std::vector<int> v;

and

std::vector<int> v = std::vector<int>();

?

As others have stated since C++17 there basically is no difference. Now as for preference of which one to use, I would suggest the following:

• If you are creating an empty vector to be filled out later then the first version is the more desirable candidate.


• If you are constructing a vector with either a default value as one of its members and or a specified count, then the later version would be the one to use.


• Note that the following two are different constructors though:
  
  
  
  
  • std::vector<int> v = std::vector<int>();
  
  
  • Is not the same constructor as:
  
  
  • 
    std::vector<int> v = std::vector<int>( 3, 10 );
  
  
  • The 2^nd version of the constructor is an overloaded constructor.
  
  
  
  


• Otherwise if you are constructing a vector from a set of numbers than you have the following options:
  
  
  
  
  • std::vector<int> v = { 1,2,3,4,5 };
  
  
  • operator=( std::initializer_list)
  
  
  • `std::vector v{ 1,2,3,4,5 };
  
  
  • list_initialization
  
  
  
  

Here is the list of std::vector constructors.