向量和原始类型初始化

Question

I've learned that if you declare for example an int in the global scope,

int x; //defaults to 0;

and in the local scope,

void f() {
    int x; //undefined
}

However if we use a vector either in the global or local scope:

vector<int> v(3); //initialise v to {0,0,0} using int's default constructor.

We can default initialise int like vector's elements in the local scope by doing this:

int x = int(); //defaults to 0

I think if we use int's default constructor it's allocated in the heap.

1. Why can't a primitive type be default initialised in the local scope like T x;? Or
2. In the local scope, why does vectors (dunno about other containers) use the element's default constructor and not leave them uninitialised just like an int declaration?
3. What are the benefits of current approach on those two types? Why are they initialised in different ways? Is this about performance?

Answer 1

It's like this for "performance" reasons, because the C++ folks wanted the C folks back in the 1980's to not have any reason to complain about "paying for what we don't need." That's one of the tenets of C++, to not pay (run-time) costs for things you don't use. So the old-style POD types are uninitialized by default, though classes and structs with constructors always have one of those constructors called.

If I were specifying it today, I'd say that int x; in local scope would be default-initialized (to 0), and if you wanted to avoid that you could say something like int x = std::noinit; . It's far too late for this now, but I have actually done it in some class types when performance mattered a lot:

class SuperFast
{
  struct no_init_t {};
public:
  no_init_t no_init;
  SuperFast() : x(0), y(0) {}
  SuperFast(no_init_t) {}

private:
  int x, y;
};

This way, default construction will give a valid object, but if you have a serious reason to need to avoid this, you can. You might use this technique if you know you will soon overwrite a whole bunch of these objects anyway--no need to default-construct them:

SuperFast sf(SuperFast::no_init); // look ma, I saved two nanoseconds!