структура определения типа: Инициализация По умолчанию
typedef struct foo
{
bool my_bool;
int my_int;
} foo;
В примере выше я понимаю, что my_bool будет инициализирован случайным образом к любому TRUE или FALSE, но что относительно my_int? Я предположил, что my_int будет значением по умолчанию, инициализированным к 0, но это, кажется, не имеет место.
Определение структур таким образом, кажется, является несовместимым со списками инициализации поэтому, что лучший способ состоит в том, чтобы инициализировать my_bool и my_int ко лжи и 0 соответственно?
7 ответов
Типы don не получить "инициализированный". Инициализируются только объектов определенного типа. Как и когда они инициализируются, зависит от того, как и где определен соответствующий объект. Вы не дали определения какого-либо объекта в своем вопросе, поэтому ваш вопрос сам по себе не имеет особого смысла - ему не хватает необходимого контекста.
Например, если вы определяете статический объект типа foo
static foo foo_object; // zeros
, он будет автоматически инициализирован нулем, потому что все объекты со статической продолжительностью всегда автоматически инициализируются нулем.
Если вы определяете автоматический объект типа foo без инициализатора, он останется неинициализированным.
void func()
{
foo foo_object; // garbage
}
Если вы определите автоматический объект типа foo с агрегатным инициализатором, он будет инициализирован в соответствии с этим инициализатором
void func()
{
foo foo_object1 = { 1, 2 }; // initialized
foo foo_object2 = {}; // initialized with zeros
}
. Если вы разместите свой объект с помощью new и не предоставите инициализатор, он останется неинициализированным
foo *p = new foo; // garbage in `*p`
Но если вы используете инициализатор () , он будет инициализирован нулем
foo *p = new foo(); // zeros in `*p`
Если вы создадите временный объект типа foo с помощью выражения foo () , результат этого выражения будет инициализирован нулем
bool b = foo().my_bool; // zero
int i = foo().my_int; // zero
Итак, еще раз, в вашем конкретном случае детали инициализации зависят от того, теперь вы создаете объект своего типа, а не от самого типа. Сам ваш тип не имеет встроенных средств инициализации и никоим образом не мешает инициализации.
Вы не создаете какой-либо объект в этом коде. Инициализация выполняется при создании объектов и не зависит от способа объявления структуры.
Например, следующее инициализирует логическое значение false , а целое число - 0
foo f = { };
Обратите внимание, что вы только что типизировали свою структуру. Вы не создали объект. Как и другие говорили, вы можете опустить typedef в C ++ и просто объявить структуру, и вы по-прежнему можете ссылаться на тип, просто сказав foo .
Если вы опускаете явную инициализацию при определении объекта, то наверняка инициализация не выполняется, если объект не определен в области пространства имен или не определен как static локально (в этом случае все члены инициализируются нулем. ) или у класса есть определяемый пользователем конструктор по умолчанию, который выполняет инициализацию соответствующим образом.
Пока вы объявляете структуры C-способом, вы можете использовать zeromemory , чтобы обнулить точно sizeof (foo) байтов, поэтому по умолчанию все значения равны 0 .
В C ++ вы можете определить свою структуру с помощью конструктора, который при необходимости установит для ваших значений некоторые значения по умолчанию.
Во-первых, способ объявления структуры соответствует стилю C. В C ++ вы должны просто сделать:
struct foo
{
bool my_bool;
int my_int;
};
И в C, и в C ++ инициализация - это отдельный этап от выделения. Если вы всегда хотите инициализировать элементы своей структуры, используйте синтаксис инициализации по умолчанию, например:
struct foo
{
bool my_bool{};
bool my_int{};
};
В более старых версиях C ++ вам нужно вручную написать конструктор по умолчанию, который инициализирует все элементы (новый синтаксис выше просто сахар для этого ):
struct foo
{
foo() : my_bool(), my_int() { }
bool my_bool;
int my_int;
};
Как отмечает @sbi, если вы хотите вручную инициализировать структуру, даже без конструктора по умолчанию, вы можете сделать foo myFoo = foo ();
Реализуйте конструктор по умолчанию:
typedef struct foo
{
foo()
: my_bool(false), my_int(0)
{
// Do nothing
}
bool my_bool;
int my_int;
} foo;
Иметь конструктор по умолчанию:
struct foo {
foo() : my_bool(false), my_int(0) {}
bool my_bool;
int my_int;
};
c и c++ вообще не инициализируют переменные. Они содержат все, что находилось в том месте памяти, в котором они сейчас находятся. Это также относится к переменным-членам в классах и структурах, если вы специально не инициализируете их значением.