c++ 在调用其构造函数之前访问静态/全局对象的成员是否有效？

Question

Is it valid and well defined (not asking whether it's pretty) to call member functions of an object in global namespace before this object's constructor has been executed (for example from a global new replacement) - and when this member function executes, are the member variables of that object guaranteed to be zero initialized and is it no error to access (and even write to) them? for example:

#include <iostream>
#include <memory>

using namespace std;

struct A {
  A() {
    new int();
  }
};

A a_;

struct B {
  B() : var(10) {
  }
  void print() {
    printf("var is %d\n", var);
    var = 5;
  }
  int var;
};

B b_;

void* operator new(size_t bytes) {
    b_.print();
    b_.print();
    return malloc(bytes);
}

int main()
{
    b_.print();
    return 0;
}

this compiles and prints

var is 0
var is 5
var is 10

but is it defined behaviour?

Answer 1

It is true that zero-initialization happens up front, but it is undefined behavior to invoke non-static class methods before their class instance is constructed. The method call itself becomes undefined behavior.

Objects in global (static) scope that are defined in the same translation unit are constructed in their declaration order (and destroyed in the opposite order).

Here, a_ gets constructed first, and then ends up invoking the new overload, which invokes a method of a class instance that has not been constructed yet, which is undefined behavior.

And if the two objects get defined in different translation units you end up with the static initialization order fiasco .

Even if you define b_ first, this is still undefined behavior unless you can guarantee that nothing in any other translation unit ends up calling this new overload. This includes the C++ library. Many C++ implementations' library do allocate some storage for their own use, so this is fairly likely to be undefined behavior as well, in the end, even if the definition order gets reversed, here.