Недавно я увидел пример следующего вида:
#include <iostream>
class Foo {
public:
int bar;
Foo(int num): bar(num) {};
};
int main(void) {
std::cout << Foo(42).bar << std::endl;
return 0;
}
Что означает этот странный : bar(num)? Кажется, что это инициализирует переменную-член, но я никогда не видел этот синтаксис раньше. Он выглядит как вызов функции/конструктора, но для int? Не имеет смысла для меня. Возможно, кто-то мог просветить меня. И, между прочим, есть ли какие-либо другие эзотерические языковые функции, подобные этому, вы никогда не найдете в обычной книге на С++?
Это список инициализации членов. Вы должны найти информацию об этом в любой хорошей книге на С++.
Вы должны в большинстве случаев инициализировать все объекты-члены в списке инициализации члена (однако обратите внимание на исключения, перечисленные в конце раздел FAQ).
Пункт выгрузки из пункта часто задаваемых вопросов состоит в том, что
При прочих равных условиях ваш код будет работать быстрее, если вы используете списки инициализации, а не назначение.
Foo(int num): bar(num)
Эта конструкция называется списком инициализаторов Member в С++.
Проще говоря, он инициализирует ваш член bar значением num.
Инициализация члена:
Foo(int num): bar(num) {};
Назначение участников:
Foo(int num)
{
bar = num;
}
Существует существенное различие между Инициализацией члена с использованием списка инициализаторов членов и присвоением ему значения внутри тела конструктора.
Когда вы инициализируете поля через список инициализаторов Member, конструкторы будут вызываться один раз, и объект будет создан и инициализирован за одну операцию.
Если вы используете назначение, тогда поля будут сначала инициализированы конструкторами по умолчанию, а затем переназначены (через оператор присваивания) с фактическими значениями.
Как вы видите, в последнем есть дополнительные накладные расходы на создание и назначение, что может быть значительным для пользовательских классов.
Cost of Member Initialization = Object Construction
Cost of Member Assignment = Object Construction + Assignment
Последнее фактически эквивалентно:
Foo(int num) : bar() {bar = num;}
В то время как первая эквивалентна просто:
Foo(int num): bar(num){}
Для встроенного (ваш пример кода) или членов класса POD практических накладных расходов нет.
Вы имеете (скорее принудительно) использовать список инициализаторов членов, если:
class MyClass
{
public:
//Reference member, has to be Initialized in Member Initializer List
int &i;
int b;
//Non static const member, must be Initialized in Member Initializer List
const int k;
//Constructor’s parameter name b is same as class data member
//Other way is to use this->b to refer to data member
MyClass(int a, int b, int c):i(a),b(b),k(c)
{
//Without Member Initializer
//this->b = b;
}
};
class MyClass2:public MyClass
{
public:
int p;
int q;
MyClass2(int x,int y,int z,int l,int m):MyClass(x,y,z),p(l),q(m)
{
}
};
int main()
{
int x = 10;
int y = 20;
int z = 30;
MyClass obj(x,y,z);
int l = 40;
int m = 50;
MyClass2 obj2(x,y,z,l,m);
return 0;
}
MyClass2 не имеет конструктора по умолчанию, поэтому он должен быть инициализирован через список инициализаторов членов.MyClass не имеет конструктора по умолчанию, поэтому для инициализации его члена нужно использовать список инициализаторов членов.Переменные класса Member всегда инициализируются в том порядке, в котором они объявлены в классе.
Они не инициализируются в том порядке, в котором они указаны в списке инициаторов Member.
Короче говоря, список инициализации Member не определяет порядок инициализации.
Учитывая вышеизложенное, всегда рекомендуется поддерживать тот же порядок членов для инициализации Member как порядок, в котором они объявлены в определении класса. Это связано с тем, что компиляторы не предупреждают о том, что оба заказа отличаются друг от друга, но относительно новый пользователь может путать список инициализаторов членов как порядок инициализации и записать код, зависящий от этого.
Эта инициализация конструктора. Это правильный способ инициализации элементов в конструкторе класса, поскольку он запрещает вызов конструктора по умолчанию.
Рассмотрим два примера:
// Example 1
Foo(Bar b)
{
bar = b;
}
// Example 2
Foo(Bar b)
: bar(b)
{
}
В примере 1:
Bar bar(); // default constructor
bar = b; // assignment
В примере 2:
Bar bar(b) // copy constructor
Все об эффективности.
Это называется списком инициализации. Это альтернативный способ инициализации членов класса. Есть преимущества использования этого вместо простого назначения новых значений членам в теле конструктора, но если у вас есть члены класса, которые являются константами или ссылками, они должны быть инициализированы.
Это не скрыто, это Синтаксис списка инициализации С++
В принципе, в вашем случае x будет инициализироваться _x, y с помощью _y, z с помощью _z.
Другой уже объяснил вам, что синтаксис, который вы наблюдаете, называется "список инициализаторов конструктора". Этот синтаксис позволяет настраивать базовые подобъекты и субобъекты членов этого класса (в отличие от разрешения инициализировать по умолчанию или оставаться неинициализированным).
Я просто хочу отметить, что синтаксис, который, как вы сказали, "выглядит как вызов конструктора", не обязательно является вызовом конструктора. В языке С++ синтаксис () - это всего лишь одна стандартная форма синтаксиса инициализации. Это интерпретируется по-разному для разных типов. Для типов классов с определяемым пользователем конструктором это означает одно (это действительно вызов конструктора), для типов классов без определяемого пользователем конструктора это означает другую вещь (так называемый инициализация значения) для пустого ()), а для типов неклассов он снова означает нечто другое (поскольку типы некласса не имеют конструкторов).
В вашем случае элемент данных имеет тип int. int не является типом класса, поэтому он не имеет конструктора. Для типа int этот синтаксис означает просто "инициализировать bar со значением num" и что он. Это делается прямо так, без каких-либо конструкторов, поскольку, опять же, int не является типом класса, поэтому он не может иметь никаких конструкторов.
Я не знаю, как вы могли это пропустить, это довольно просто. Это синтаксис для инициализации переменных-членов или конструкторов базового класса. Он работает для простых старых типов данных, а также для объектов класса.
Это список инициализации. Он инициализирует элементы до того, как будет запущен тело конструктора. Рассмотрим
class Foo {
public:
string str;
Foo(string &p)
{
str = p;
};
};
vs
class Foo {
public:
string str;
Foo(string &p): str(p) {};
};
В первом примере str будет инициализироваться конструктором без аргументов
string();
перед телом конструктора Foo. Внутри конструктора foo
string& operator=( const string& s );
будет вызываться на 'str', как вы делаете str = p;
Во втором примере str будет инициализироваться непосредственно вызов его конструктора
string( const string& s );
с 'p' в качестве аргумента.
Вы правы, это действительно способ инициализации переменных-членов. Я не уверен, что для этого есть много пользы, кроме как ясно выражая, что это инициализация. Наличие "bar = num" внутри кода может быть легко перемещено, удалено или неверно истолковано.
есть еще одно "преимущество"
если тип переменной-члена не поддерживает инициализацию нуля или если ее ссылка (которая не может быть инициализирована нулем), то у вас нет выбора, кроме как предоставить список инициализации
Это список инициализации для конструктора. Вместо стандартного построения x, y и z, а затем присваивая им значения, полученные в параметрах, эти члены будут инициализированы этими значениями сразу же с места в карьер. Это может показаться не очень полезным для float s, но это может быть довольно многопользовательский режим с настраиваемыми классами, которые дороги для построения.
Не упоминается еще в этом потоке: поскольку С++ 11, список инициализаторов членов может использовать инициализацию списка (ака. "равномерная инициализация", "согласованная инициализация" ):
Foo(int num): bar{num} {}
который имеет ту же семантику, что и инициализация списка в других контекстах.