Что означает {0} при инициализации объекта?

То, что здесь происходит, называется инициализацией совокупность. Вот (сокращенное) определение агрегата из раздела 8.5.1 спецификации ISO:

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.

Теперь использование {0} для инициализации подобного агрегата - это, по сути, трюк с 0 в целом. Это связано с тем, что при использовании агрегированной инициализации вам не нужно указывать всех участников и спецификация требует, чтобы все неуказанные элементы были инициализированы по умолчанию, что означает установку 0 для простых типов.

Вот соответствующая цитата из спецификации:

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.

Вы можете найти полную спецификацию по этой теме здесь

Прошло некоторое время с тех пор, как я работал с c / C++, но IIRC, тот же ярлык можно использовать и для массивов.

Я также использую его для инициализации строк, например.

char mytext[100] = {0};

Следует помнить, что этот метод не устанавливает байты заполнения в ноль. Например:

struct foo
{
    char c;
    int  i;
};

foo a = {0};

Не то же самое, что:

foo a;
memset(&a,0,sizeof(a));

В первом случае байты заполнения между c и i не инициализируются. Зачем тебе это нужно? Что ж, если вы сохраняете эти данные на диск или отправляете их по сети или что-то еще, у вас может быть проблема с безопасностью.

Обратите внимание, что пустой инициализатор агрегата также работает:

SHELLEXECUTEINFO sexi = {};
char mytext[100] = {};

В ответ на вопрос, почему происходит сбой ShellExecuteEx(): ваша структура "sexi" SHELLEXECUTEINFO имеет много членов, и вы инициализируете только некоторые из них.

Например, член sexi.lpDirectory может указывать куда угодно, но ShellExecuteEx() все равно будет пытаться его использовать, поэтому вы получите нарушение доступа к памяти.

Когда вы включаете строку:

SHELLEXECUTEINFO sexi = {0};

перед настройкой остальной структуры вы говорите компилятору обнулить элементы структуры все перед инициализацией тех, которые вас интересуют. ShellExecuteEx() знает, что если sexi.lpDirectory равен нулю, он должен игнорировать его.

Мне всегда было интересно, Почему вы должны использовать что-то вроде

struct foo bar = { 0 };

Вот пример для объяснения:

check.c

struct f {
    int x;
    char a;
} my_zero_struct;

int main(void)
{
    return my_zero_struct.x;
}

Я компилирую с помощью gcc -O2 -o check check.c, а затем выводю таблицу символов с помощью readelf -s check | sort -k 2 (это с gcc 4.6.3 в ubuntu 12.04.2 в системе x64). Отрывок:

59: 0000000000601018     0 NOTYPE  GLOBAL DEFAULT  ABS __bss_start
48: 0000000000601018     0 NOTYPE  GLOBAL DEFAULT  ABS _edata
25: 0000000000601018     0 SECTION LOCAL  DEFAULT   25 
33: 0000000000601018     1 OBJECT  LOCAL  DEFAULT   25 completed.6531
34: 0000000000601020     8 OBJECT  LOCAL  DEFAULT   25 dtor_idx.6533
62: 0000000000601028     8 OBJECT  GLOBAL DEFAULT   25 my_zero_struct
57: 0000000000601030     0 NOTYPE  GLOBAL DEFAULT  ABS _end

Важной частью здесь является то, что my_zero_struct следует за __bss_start. Раздел ".bss" в программе на языке C - это раздел памяти, который установлен в ноль. перед. main называется, см. википедия на .bss.

Если вы измените приведенный выше код на:

} my_zero_struct = { 0 };

Тогда результирующий исполняемый файл "проверки" выглядит как точно, по крайней мере, с компилятором gcc 4.6.3 в ubuntu 12.04.2; my_zero_struct все еще находится в секции .bss, и поэтому он будет автоматически инициализирован нулем перед вызовом main.

Подсказки в комментариях, что memset может инициализировать «полную» структуру, также не является улучшением, потому что раздел .bss полностью очищен, что также означает, что «полная» структура установлена ​​в ноль.

мог бы - это потому, что стандарт языка C не упоминает ничего из этого, но в реальном компиляторе C я никогда не видел другого поведения.

{0} - это анонимный массив, в котором его элемент равен 0.

Используется для инициализировать один или все элементы массива с помощью 0.

например int arr [8] = {0};

В этом случае все элементы arr будут инициализированы как 0.

{0} является допустимым инициализатором для любого типа (полного объекта) как в C, так и в C++. Это обычная идиома, используемая для инициализации объекта нуль (прочтите, чтобы узнать, что это означает).

Для скалярных типов (арифметических и указательных типов) фигурные скобки не нужны, но явно разрешены. Цитата N1570 проект стандарта ISO C, раздел 6.7.9:

The initializer for a scalar shall be a single expression, optionally enclosed in braces.

Он инициализирует объект нулем (0 для целых чисел, 0.0 для чисел с плавающей запятой, нулевой указатель для указателей).

Для нескалярных типов (структуры, массивы, объединения) {0} указывает, что элемент первый объекта инициализируется нулем. Для структур, содержащих структуры, массивы структур и т. д., Это применяется рекурсивно, поэтому первый скалярный элемент устанавливается в ноль, в зависимости от типа. Как и в любом инициализаторе, любые неуказанные элементы обнуляются.

Промежуточные скобы ({, }) можно не устанавливать; например, оба они действительны и эквивалентны:

int arr[2][2] = { { 1, 2 }, {3, 4} };

int arr[2][2] = { 1, 2, 3, 4 };

вот почему вам не нужно писать, например, { { 0 } } для типа, первый элемент которого не скалярен.

Итак, это:

some_type obj = { 0 };

- это сокращенный способ инициализации obj нулем, означающий, что каждому скалярному подобъекту obj присваивается значение 0, если это целое число, 0.0, если это число с плавающей запятой, или нулевой указатель, если это указатель.

Правила аналогичны для C++.

В вашем конкретном случае, поскольку вы присваиваете значения sexi.cbSize и т. д., Ясно, что SHELLEXECUTEINFO является типом структуры или класса (или, возможно, объединением, но, вероятно, нет), поэтому не все из этого применимо, но, как я сказал, { 0 } - это распространенная идиома, которую можно использовать в более общих ситуациях.

Это нет (обязательно) эквивалентно использованию memset для установки представления объекта на все биты-ноль. Ни 0.0 с плавающей запятой, ни нулевой указатель не обязательно представлены как все биты-ноль, и инициализатор { 0 } не обязательно устанавливает байты заполнения в какое-либо конкретное значение. Однако в большинстве систем это может иметь тот же эффект.

Это синтаксический сахар для инициализации всей вашей структуры пустыми / нулевыми / нулевыми значениями.

Длинная версия

SHELLEXECUTEINFO sexi;
sexi.cbSize = 0;
sexi.fMask = 0;
sexi.hwnd = NULL;
sexi.lpVerb = NULL;
sexi.lpFile = NULL;
sexi.lpParameters = NULL;
sexi.lpDirectory = NULL;
sexi.nShow = nShow;
sexi.hInstApp = 0;
sexi.lpIDList = NULL;
sexi.lpClass = NULL;
sexi.hkeyClass = 0;
sexi.dwHotKey = 0;
sexi.hMonitor = 0;
sexi.hProcess = 0;

Укороченная версия

SHELLEXECUTEINFO sexi = {0};

Разве это не было намного проще?

Еще это приятно, потому что:

• вам не нужно выслеживать каждого участника и инициализировать его
• вам не нужно беспокоиться о том, что вы можете не инициализировать новых участников, когда они будут добавлены позже
• вам не обязательно позвоните ZeroMemory