new keyword

[gautamreloaded]

Fred* p = new Fred();
Fred* p = new Fred[];

what's the difference between these two statement ;

[o1vk4iN6]

new Fred[]; shouldn't compile, it requires a parameter to determine the size of the array of objects to allocate.

new Fed[10];

[jwkNwA7f]

Fred* p = new Fred(); This allocates an object.
Fred* p = new Fred[]; This allocates an array of objects, as mentioned by xerzi. Like xerzi said, it should have the number of objects between the brackets.

EDIT: Wow, my 500th post!

[andywestken]

As well as

Fred* p = new Fred();
Fred* p = new Fred[42]; // now with the required size (which can be 0) 

you're got these, too

Fred* p = new Fred;
Fred* p = new Fred[42]();

and if your compiler understands C++11, the curly braces {} forms as well

Fred* p = new Fred{};
Fred* p = new Fred[42]{};

Andy

[Disch]

Fred* p = new Fred[42]();

Does that work? I didn't think you could invoke constructors when using new[]... it just always uses the default ctor.

[Dy7SLyTq]

nope disch is right.
http://ideone.com/ZKo5S8

[andywestken]

Works for me, with GCC and MSVC

But the () isn't constructor invocation. It's value initialization.

If you provide an explicit default constructor, that will be used and the initialization does nothing. But if you don't provide an explicit constructor, you get:

without ()s

  -842150451

  -842150451
  -842150451
  -842150451
  -842150451

with ()s

  0

  0
  0
  0
  0

(the "rubbish" in the memory is regular here as it's a MSVC debug build, and the debug version of the CRT library fills newly allocated memory with the fixed pattern: 0xCDCDCDCD)

#include <iostream>
using namespace std;

#define NO_EXPLICIT_CONSTRUCTOR

class Fred
{
public:
#ifdef NO_EXPLICIT_CONSTRUCTOR
  // no constructor
#else
  Fred() : ballChange(1)
  {
    // "forgot" to init step
  }
#endif
  int step;
  int ballChange;
};

int main()
{
  int count = 4;

  Fred* p1  = new Fred;
  Fred* pa1 = new Fred[count];

  Fred* p2  = new Fred();
  Fred* pa2 = new Fred[count]();

  cout << "without ()s" << endl;
  cout << endl;

  cout << "  " << p1->step << endl;
  cout << endl;
  for(int i = 0; count > i; ++i)
    cout << "  " << pa1[i].ballChange << endl;
  cout << endl;

  cout << "with ()s" << endl;
  cout << endl;

  cout << "  " << p2->step << endl;
  cout << endl;
  for(int i = 0; count > i; ++i)
    cout << "  " << pa2[i].ballChange << endl;
  cout << endl;

  delete    p1;
  delete [] pa1;

  delete    p2;
  delete [] pa2;

  return 0;
}

Andy

value initialization
http://en.cppreference.com/w/cpp/language/value_initialization
(the example code here includes the array case.)

With the faulty, explicit constructor the output is:

without ()s

  -842150451, 1

  -842150451, 1
  -842150451, 1
  -842150451, 1
  -842150451, 1

with ()s

  -842150451, 1

  -842150451, 1
  -842150451, 1
  -842150451, 1
  -842150451, 1

[JLBorges]

Uniform initialization is supported when an object is created with a new expression.

#include <iostream>
#include <memory>

struct Fred
{
  int step;
  int ballChange;
};

std::ostream& operator<< ( std::ostream& stm, const Fred& f )
{ return stm << "Fred{" << f.step << ',' << f.ballChange << '}' ; }

int main()
{
    constexpr int N = 5 ;

    {
        // value initialization
        std::unique_ptr< Fred[] > p( new Fred[N] () ) ;
        for( int i = 0 ; i < N ; ++i ) std::cout << p[i] << ' ' ;
        std::cout << '\n' ;
    }

    {
        // aggregate initialization
        std::unique_ptr< Fred[] > p( new Fred[N] { {0,1}, {2,3}, {4,5} } ) ;
        for( int i = 0 ; i < N ; ++i ) std::cout << p[i] << ' ' ;
        std::cout << '\n' ;
    }

    // etc.
}

http://ideone.com/URvmbm