New array allocations

Question

So i have this class called point, just to log to the console everytime an object gets constructed and destroyed. And i did the following:

#include <iostream>

struct point{
    point() {
        std::cout << "ctor\n";
    }
    ~point() {
        std::cout << "dtor\n";
    }
};
    int main(){
    int x = 3;
    point* ptr = new point[x]{point()};
    delete[] ptr;
}

ctor
dtor
dtor
dtor

This ended up calling the constructor just once, and the destructor 3 times, why? I know that this is bad, probably ub, but i would like to understand why. This other allocations give me the "expected" output:

int x = 3;
constexpr int y = 3;
point* ptr1 = new point[3];
point* ptr2 = new point[x];
point* ptr3 = new point[y]{point()};

ctor
ctor
ctor
dtor
dtor
dtor

Im using visual studio 19 latest version.

Answer 1

This is a compiler bug.

By using operator new without a constant defined type size MSVC compiler will call the class object constructor and destructor as many times as explicitly specified at initializer list and/or array size.

#include <iostream>

struct point {
    point() {
        std::cout << "ctor\n";
    }
    ~point() {
        std::cout << "dtor\n";
    }
};
int main() {
    int x = 3;
    point* ptr = new point[x]{point()};
    delete[] ptr;
}

As stated will call as explicitly specified point ctor once.

This can be asserted by: point* ptr = new point[x]{point(), point()};

• MSVC Output: ctor ctor dtor dtor dtor.
• GCC: ctor ctor ctor dtor dtor dtor (which should be guaranteed)

And even a throwable array out of bound exception UB: point* ptr = new point[x]{point(), point(), point(), point(), point() }; follows the behavior.

• MSVC Output: ctor ctor ctor ctor ctor dtor dtor dtor.
• GCC: terminate called after throwing an instance of 'std::bad_array_new_length'

Too many initializers is correctly detected if the defined size is constant. i.e const int x = 3 or constexpr int x = 3