Когда мне нужно использовать списки инициализаторов для инициализации членов класса C ++?

m_somemap

1. Вы не обязаны.
2. Что вы получите, если опустите его: пустой std::map< std::string, std::string >, то есть действительный экземпляр этой карты, в котором нет элементов.

m_somebool

1. Вы должны инициализировать его true или false, если хотите, чтобы оно имело известное значение. Логические значения - это «простые старые типы данных», и они не имеют концепции конструктора. Более того, язык C ++ не определяет значения по умолчанию для неявно инициализированных логических значений.
2. Что вы получите, если его опустите: логический член с неопределенным значением. Вы не должны делать этого, а затем использовать его значение. По этой причине настоятельно рекомендуется инициализировать все значения этого типа.

m_someint

1. Вы должны инициализировать его некоторым целочисленным значением, если хотите, чтобы оно имело известное значение. Целые числа - это «простые старые типы данных», и они не имеют концепции конструктора. Более того, язык C ++ не определяет значения по умолчанию для неявно инициализированных целых чисел.
2. Что вы получите, если его опустите: член типа int с неопределенным значением. Вы не должны делать этого, а затем использовать его значение. По этой причине настоятельно рекомендуется инициализировать все значения этого типа.

На самом деле в этом нет необходимости.
Конструктор по умолчанию сделает это автоматически.

Но иногда, делая это явным, он действует как своего рода документация:

class X
{
    std::map<string,string>  data;
    Y                        somePropertyOfdata;

    X()
      :data()                    // Technically not needed
      ,somePropertyOfdata(data)  // But it documents that data is finished construction
    {}                           // before it is used here.
};

Правило C ++ состоит в том, что, если вы явно не инициализируете данные POD, они не определены, в то время как другие классы имеют конструктор по умолчанию, вызываемый автоматически (даже если это явно не сделано программистом).

Но говоря это. Учти это:

template<typename T>
class Z
{
     T  data;   
     Z()
        :data()    // Technicall not need as default constructor will
                   // always be called for classes.
                   // But doing this will initialize POD data correctly
                   // if T is a basic POD type. 
     {}
};

Здесь вы ожидаете, что данные будут инициализированы по умолчанию.
Технически POD не имеет конструкторов, поэтому, если бы T был int, ожидали бы вы, что он что-нибудь сделает? Поскольку он был явно инициализирован, он установлен в 0 или эквивалент для типов POD.

Для редактирования:

class A
{
    std::map<string,string>   m_someMap;
    int                       m_someint;
    bool                      m_somebool;
   public:
    A::A()
       : m_someMap()      // Class will always be initialised (so optional)
       , m_someint(0)     // without this POD will be undefined
       , m_somebool(false)// without this POD will be undefined
    {}
};

Как отмечали другие: это не обязательно, но более или менее вопрос стиля. Плюс: он показывает, что вы явно хотите использовать конструктор по умолчанию, и делает ваш код более подробным. Обратная сторона: если у вас более одного ctor, может быть сложно поддерживать изменения во всех из них, и иногда вы добавляете членов класса и забываете добавить их в список инициализаторов ctors, чтобы он выглядел несогласованным.

A::A() : m_someMap()

В этом случае эта строка не нужна. Однако, в целом, это единственный правильный способ инициализировать члены класса.

Если у вас есть такой конструктор:

X() : y(z) {
 w = 42;
}

то при вызове конструктора X происходит следующее:

• Сначала инициализируются все члены: для y мы явно говорим, что хотим вызвать конструктор, который принимает z в качестве аргумента. Для w то, что происходит, зависит от типа w. Если w является типом POD (то есть в основном C-совместимым типом: без наследования, без конструкторов или деструкторов, все члены являются общедоступными и все члены также являются типами POD), то это не инициализирован. Его начальное значение - это мусор, обнаруженный по этому адресу памяти. Если w не является типом POD, то вызывается его конструктор по умолчанию (типы, отличные от POD, всегда инициализируются при построении).
• После создания обоих членов мы затем вызываем оператор присваивания, чтобы присвоить 42 w.

Важно отметить, что все конструкторы вызываются перед, когда мы вводим тело конструктора. Когда мы в теле, все члены уже инициализированы. Итак, есть две возможные проблемы с нашим телом конструктора.

• Что, если w относится к типу, не имеющему конструктора по умолчанию? Тогда это не будет компилироваться. Затем он должен быть явно инициализирован после :, как y.
• Что, если эта последовательность вызова и конструктора по умолчанию и оператора присваивания будет излишне медленной? Возможно, было бы намного эффективнее для начала просто вызвать правильный конструктор.

Короче говоря, поскольку m_someMap не является типом POD, нам, строго говоря, не нужно делать : m_someMap(). В любом случае он был бы построен по умолчанию. Но если бы это был тип POD или если бы мы хотели вызвать другой конструктор, отличный от конструктора по умолчанию, то нам пришлось бы это сделать.

Просто чтобы прояснить, что происходит (в отношении вашего второго вопроса)

std::map< std::string, std::string > m_someMap создает переменную стека с именем m_someMap, и для нее вызывается конструктор по умолчанию. Правило C ++ для всех ваших объектов:

T varName;

где T - тип, по умолчанию создается varName.

T* varName;

должно быть явно присвоено NULL (или 0) - или nullptr в новом стандарте.

Чтобы прояснить проблему со значением по умолчанию:

В C ++ нет концепции имплицитности некоторых типов по ссылке. Если что-то явно не объявлено как указатель, оно не может никогда принимать нулевое значение. Это означает, что каждый класс будет иметь конструктор по умолчанию для построения начального значения, когда не указаны параметры конструктора. Если конструктор по умолчанию не объявлен, компилятор сгенерирует его за вас. Кроме того, всякий раз, когда класс содержит члены классифицированных типов, эти члены будут неявно инициализированы через их собственные конструкторы по умолчанию при создании объекта, если вы не используете синтаксис двоеточия для явного вызова другого конструктора.

Так уж получилось, что конструктор по умолчанию для всех типов контейнеров STL создает пустой контейнер. Другие классы могут иметь другие соглашения о том, что делают их конструкторы по умолчанию, поэтому вы все равно хотите знать, что они вызываются в подобных ситуациях. Вот почему строка A::A() : m_someMap(), которая на самом деле просто говорит компилятору сделать то, что он уже сделал бы.

Когда вы создаете объект на C ++, конструктор выполняет следующую последовательность:

1. Вызвать конструкторы всех родительских виртуальных классов во всем дереве классов (в произвольном порядке)
2. Вызов конструкторов всех напрямую наследуемых родительских классов в порядке объявления
3. Вызов конструкторов всех переменных-членов в порядке объявления

Есть еще несколько особенностей, чем это, и некоторые компиляторы позволяют вам вывести некоторые вещи из этого конкретного порядка, но это общая идея. Для каждого из этих вызовов конструктора вы можете указать аргументы конструктора, и в этом случае C ++ вызовет конструктор, как указано, или вы можете оставить его в покое, и C ++ попытается вызвать конструктор по умолчанию. Конструктор по умолчанию - это просто тот, который не принимает аргументов.

Если какой-либо из ваших виртуальных родительских классов, невиртуальных родительских классов или переменных-членов не имеет конструктора по умолчанию или должен быть создан с чем-то другим, кроме значения по умолчанию, вы добавляете их в список вызовов конструктора. Поскольку C ++ предполагает вызов конструктора по умолчанию, нет абсолютно никакой разницы между помещением конструктора по умолчанию в список и его полным исключением (C ++ не будет (за исключением особых обстоятельств, выходящих за рамки этого вопроса) создавать объект без вызова конструктор какой-то). Если у класса нет конструктора по умолчанию и вы не предоставляете вызов конструктора, компилятор выдаст ошибку.

Когда дело доходит до встроенных типов, таких как float или int, конструктор по умолчанию вообще ничего не делает, и поэтому переменная будет иметь значение по умолчанию из того, что осталось в части памяти. Все встроенные типы также имеют конструктор копирования, поэтому вы можете инициализировать их, передав их начальное значение в качестве единственного аргумента конструктору переменной.