<p>When <code>{0}</code> is used to initialize an object, what does it mean? I can't find any references to <code>{0}</code> anywhere, and because of the curly braces Google searches are not helpful.</p>

<p>Example code:</p>

<pre><code>SHELLEXECUTEINFO sexi = {0}; // what does this do?
sexi.cbSize = sizeof(SHELLEXECUTEINFO);
sexi.hwnd = NULL;
sexi.fMask = SEE_MASK_NOCLOSEPROCESS;
sexi.lpFile = lpFile.c_str();
sexi.lpParameters = args;
sexi.nShow = nShow;

if(ShellExecuteEx(&amp;sexi))
{
    DWORD wait = WaitForSingleObject(sexi.hProcess, INFINITE);
    if(wait == WAIT_OBJECT_0)
        GetExitCodeProcess(sexi.hProcess, &amp;returnCode);
}
</code></pre>

<p>Without it, the above code will crash on runtime.</p>

What's happening here is called
aggregate
initialization.  Here is the (abbreviated) definition of an aggregate from section 8.5.1 of the ISO spec:
An aggregate is an array or a class with no user-declared constructors, no private or protected non-static data members, no base classes, and no virtual functions.
Now, using
```
{0}
```
to initialize an aggregate like this is basically a trick to
```
0
```
the entire thing.  This is because when using aggregate initialization
you don't have to specify all the members
and the spec requires that all unspecified members be default initialized, which means set to
```
0
```
for simple types.
Here is the relevant quote from the spec:
If there are fewer initializers in the list than there are members in the
  aggregate, then each member not
  explicitly initialized shall be
  default-initialized.
  Example:
```
```
struct S { int a; char* b; int c; };
S ss = { 1, "asdf" };
```
```
initializes
```
ss.a
```
with
```
1
```
,
```
ss.b
```
with
```
"asdf"
```
, and
```
ss.c
```
with the value of an
  expression of the form
```
int()
```
, that is,
```
0
```
.
You can find the complete spec on this topic
here