struct base
{
  int i;
  char c;
};

struct derived : base
{
  double d;
};

#include <stdio.h>

int main()
{  
 base b = base();
 printf("b.i - %d\n", b.i);
 printf("b.c - %d\n", (int)b.c);

 derived d = derived();
 printf("d.i - %d\n", d.i);
 printf("d.c - %d\n", (int)d.c);
 printf("d.d - %f\n", d.d);
}

b.i — 0
b.c — 0
d.i — 0
d.c — 0
d.d — 0.00000

b.i — 0
b.c — 0
d.i — -858993460
d.c — -52
d.d — -925596....

struct derived /* : base*/
{
  base b;
  double d;
};

derived* pd = new derived();
derived& d = *pd;

...

derived d;
new (&d) derived();

struct nontrivial
{
  nontrivial() : member(4) {}
  ~nontrivial() {}

  int member;
};

struct base
{
  int i;
  char c;

  nontrivial n;
};

struct derived : base
{
  double d;
};

#include <stdio.h>
#include <new>

int main()
{  
 base b = base();
 printf("b.i - %d\n", b.i);
 printf("b.c - %d\n", (int)b.c);
 printf("b.n.member - %d\n", b.n.member);

 derived d = derived();
 new (&d) derived(); // Workaround ??
 printf("d.i - %d\n", d.i);
 printf("d.c - %d\n", (int)d.c);
 printf("d.d - %f\n", d.d);
}

b.i — -858993460
b.c — -52
b.n.member — 4
d.i — -858993460
d.c — -52
d.d — -925596....

T x = {};

T const &t1 = T(); // разрешено копирование (C++03)
T t2 = T(); // разрешено копирование

If a given nonstatic data member or base class is not named by a mem-initializer-id (including the case where there is no mem-initializer-list because the constructor has no ctor-initializer), then
— If the entity is a nonstatic data member of (possibly cv-qualified) class type (or array thereof) or a base class, and the entity class is a non-POD class, the entity is default-initialized (8.5). If the entity is a nonstatic data member of a const-qualified type, the entity class shall have a user-declared default constructor.
— Otherwise, the entity is not initialized. If the entity is of const-qualified type or reference type, or of a (possibly cv-qualified) POD class type (or array thereof) containing (directly or indirectly) a member of a const-qualified type, the program is ill-formed.

b.i — 0
b.c — 0
d.i — 4206624
d.c — 40
d.d — 0.000000

__>Берегитесь

b.i — 0
b.c — 36
b.n.member — 4
d.i — 1076296996
d.c — 36
d.d — 0.000000
d.n.member — 4

__>Берегитесь

#include <stdio.h>

#include <string>

struct check
{
    std::string s;
    int i;
};

static check c = check();
static check d;

struct basecheck2
{
    int i;
};

struct check2 : basecheck2
{
    char c;
};

static check2 c2 = check2();
static check2 d2;

int main()
{
  printf("%d\n", c.i);
  printf("%d\n", c2.i);
}

0
-858993460

If no initializer is specified for an object, and the object is of (possibly cv-qualified) non-POD class type (or array thereof), the object shall be default-initialized; if the object is of const-qualified type, the underlying class type shall have a user-declared default constructor. Otherwise, if no initializer is specified for a non-static object, the object and its subobjects, if any, have an indeterminate initial value; if the object or any of its subobjects are of const-qualified type, the program is ill-formed.

struct basecheck2
{
    int i;
};
static basecheck2 b = basecheck2();
...
//и вывод его на печать

  printf("%d\n", c.i);
  printf("%d\n", c2.i);
  printf("%d\n", b.i);

#include <stdio.h>

#include <string>

struct check
{
    std::string s;
    int i;
};

static check c = check();
static check d;

struct basecheck2
{
    int i;
};

struct check2 : basecheck2
{
    char c;
};

static check2 c2 = check2();
static check2 d2;

static basecheck2 b = basecheck2();

int main()
{
  printf("%d\n", c.i);
  printf("%d\n", c2.i);
  printf("%d\n", b.i);
}

Output:
134543672
0
0

Если это не-POD-класс-тип без явно объявленного конструктора, то в первом случае будет рекурсивно применена value-initialization к каждому подобъекту этого класса (что при этом получится — зависит о типов этих подобъектов),

new T();

The expression T(), where T is a simple-type-specifier (7.1.5.2) for a non-array complete object type or the (possibly cv-qualified) void type, creates an rvalue of the specified type, whose value is determined by default-initialization which is value-initialized (8.5; no initialization is done for the void() case).
[Note: if T is a non-class type that is cv-qualified, the cv-qualifiers are ignored when determining the type of the resulting rvalue (3.10). ]

When no initializer is specified for an object of (possibly cv-qualified) class type (or array thereof), or the
initializer has the form (), the object is initialized as specified in 8.5. [Note: if the class is a non-POD, it is default-initialized.] The object is default-initialized if
there is no initializer, or value-initialized if the initializer is ().

An implicitly-declared default constructor for a class is implicitly defined when it is used to create an object
of its class type (1.8). The implicitly-defined default constructor performs the set of initializations of the
class that would be performed by a user-written default constructor for that class with an empty meminitializer-
list (12.6.2) and an empty function body. If that user-written default constructor would be illformed,
the program is ill-formed. Before the implicitly-declared default constructor for a class is implicitly
defined, all the implicitly-declared default constructors for its base classes and its nonstatic data members
shall have been implicitly defined. [Note: an implicitly-declared default constructor has an exceptionspecification
(15.4). ]

To value-initialize an object of type T means:
— if T is a class type (clause 9) with a user-declared constructor (12.1), then the default constructor for T is
called (and the initialization is ill-formed if T has no accessible default constructor);
— if T is a non-union class type without a user-declared constructor, then every non-static data member
and base-class component of T is value-initialized;
— if T is an array type, then each element is value-initialized;
— otherwise, the object is zero-initialized

struct A { int x; };
struct B : A { int y; };
struct C : A { int z; virtual void foo() {} };

int main()
{
  A a1;       // VC, gcc: not initialized
  A a2 = A(); // VC, gcc: value-initialize => zero-initialize

  B b1;       // VC, gcc: default ctor => not initialized
  B b2 = B(); // VC: default ctor => not initialized
              // gcc: value-initialize => zero-initialize

  C c1;       // VC, gcc: default ctor => not initialized
  C c2 = C(); // VC, gcc: default ctor => not initialized
              // vfptr они, разумеется, установили
}

SD>T x = {};
SD>

SD> или еще что нибудь и не парили людям мозг этими "смысловыми перегрузками".

// no init (POD) / default init (non-POD)
T x;
T* px = new T;

// value=zero init (POD & POD-like) / default init (non-POD)
T x = T();
T* px = new T();

template<class T>
struct Holder
{
  T data;
  Holder() {}
  operator T&() { return data; ]
  operator T const&() { return data; }
  // для панков
  T* operator&() { return &data; }
  T const* operator&() { return &data; }
};

char buffer[sizeof(T)];

memset(&buffer[0], 0, sizeof(T));
new (&buffer[0]) T();

T var[1] = {}; // *var is value-initialized

T var[1] = {}; // *var is value-initialized

struct nontrivial
{
  nontrivial() : member(4) {}
  ~nontrivial() {}

  int member;
};

struct base
{
  int i;
  char c;

  nontrivial n;
};

#include <stdio.h>


int main()
{  
  base bb[1] = {};
  base& b = bb[0];
  printf("b.i - %d\n", b.i);
  printf("b.c - %d\n", (int)b.c);
  printf("b.n.member - %d\n", b.n.member);
}

b.i — -858993460
b.c — -52
b.n.member — 4

struct Foo
{
  int x[1000];
  // и никаких конструкторов
};

void buz(const Foo&);

void bar()
{
  Foo f; // default/не инициализирована
  Foo g = {}; // value-инициализирована
  Foo h = Foo(); // value-инициализирована

  Foo *pf = new Foo; // default/не инициализирована
  Foo *ph = new Foo(); // value-инициализирована

  buz(Foo()); // value-инициализирована
  buz(Holder<Foo>()); // default/не инициализирована - вот здесь пришлось надстраиваться над синтаксисом
}

SD>YMMV разумеется