标签: initialization-list

假设我有以下课程:

class MyInteger {
private:
  int n_;
public:
  MyInteger(int n) : n_(n) {};
  // MORE STUFF
};

并且假设这个类没有默认的普通构造函数MyInteger().int出于某种原因,我必须始终提供初始化它.然后假设在我的代码中的某个地方我需要一个vector<MyInteger>.如何MyInteger在此初始化每个组件vector<>？

我有两种情况(可能解决方案是相同的,但无论如何我都会说明),一个函数内的正常变量:

int main(){
    vector<MyInteger> foo(10);  //how do I initialize each 
                                //MyInteger field of this vector? 
    doStuff(foo);
}

并作为班级中的数据:

class MyFunClass {
private:
   vector<MyInteger> myVector;

public:
   MyFunClass(int size, int myIntegerValue) : myVector(size) {}; 
   // what do I put here if I need the 
   // initialization to call MyInteger(myIntegerValue) for all 
   // components of …

考虑以下(简化)情况:

class Foo
{
private:
    int evenA;
    int evenB;
    int evenSum;
public:
    Foo(int a, int b) : evenA(a-(a%2)), evenB(b-(b%2)), evenSum(evenA+evenB)
    {
    }
};

当我像这样实现Foo时:

Foo foo(1,3);

然后evenA是0,evenB是2,但是甚至将初始化为2？

我在我当前的平台(iOS)上尝试了这个,它似乎工作,但我不确定这段代码是否可移植.

谢谢你的帮助!

我有一个数组成员的类,我想初始化为全零.

class X
{
private:
    int m_array[10];
};

对于局部变量,有一种简单的零初始化方法(参见此处):

int myArray[10] = {};

此外,类成员m_array显然需要初始化,因为默认初始化整数会见好就收随机的垃圾,如解释在这里.

但是,我可以看到两种方法为成员数组执行此操作:

括号:

public:
    X()
    : m_array()
    {}

带括号:

public:
    X()
    : m_array{}
    {}

两个都正确吗？这两者在C++ 11中有什么区别吗？

我有C++代码,归结为如下所示:

class Foo{
    bool bar;
    bool baz;
    Foo(const void*);
};
Foo::Foo(const void* ptr){
    const struct my_struct* s = complex_method(ptr);
    bar = calculate_bar(s);
    baz = calculate_baz(s);
}

从语义上讲,bar和baz成员变量应该是const,因为它们在初始化后不应该更改.但是,似乎为了使它们如此,我需要在初始化列表中初始化它们而不是分配它们.要清楚,我理解为什么我需要这样做.问题是,我似乎无法找到任何方法将代码转换为初始化列表而不执行以下不良操作之一:

• 打complex_method两次电话(对性能不好)
• 将指针添加到Foo类(会使类大小不必要地变大)

有没有办法让变量const同时避免这些不良情况？

我有一个关于在派生类的构造函数中初始化继承成员的问题.示例代码:

class A
    {
public:
    int m_int;
    };

class B: public A
    {
public:
    B():m_int(0){}
    };

这段代码给了我以下输出:

In constructor 'B::B()': Line 10: error: class 'B' does not have any field named 'm_int'

(见http://codepad.org/tn1weFFP)

我猜这是为什么会这样？m_int应该是on的成员B,并且A当m_intin的初始化B发生时,父类应该已经被初始化(因为父构造函数在继承类的成员初始化之前运行).我的推理错在哪里？这段代码到底发生了什么？

EDIT:我知道初始化这个成员的其他可能性(基础构造函数或派生构造函数中的赋值),但我想理解为什么它在我尝试的方式中是非法的？一些特定的C++语言功能还是这样的？如果可能的话,请指出C++标准的段落.

是否可以在c ++中将引用成员初始化为NULL？
我正在尝试这样的事情:

class BigClass
{
private:
  Object m_inner;
public:
  const Object& ReadOnly;
  BigClass() : ReadOnly(NULL)
  {
    Do stuff.
  }
};

我知道我能做到这一点,如果我初始化"只读"到对象的实际的参考,但是当我想摆在那里"NULL",我得到的错误:

"无法从'int'转换为'const Object&'

我怎么解决这个问题？

我有2个资源管理类DeviceContext,OpenGLContext都是class DisplayOpenGL.资源生命周期与之相关DisplayOpenGL.初始化看起来像这样(伪代码):

DeviceContext m_device = DeviceContext(hwnd);
m_device.SetPixelFormat();
OpenGLContext m_opengl = OpenGLContext(m_device);

问题是调用SetPixelFormat(),因为我无法在DisplayOpenGLc'tor 的初始化列表中执行此操作:

class DisplayOpenGL {
public:
    DisplayOpenGL(HWND hwnd)
    : m_device(hwnd),
      // <- Must call m_device.SetPixelFormat here ->
      m_opengl(m_device) { };
private:
    DeviceContext m_device;
    OpenGLContext m_opengl;
};

我能看到的解决方案:

• 插入m_dummy(m_device.SetPixelFormat())- 无法工作,因为SetPixelFormat()没有retval.(如果它有一个retval,你应该这样做吗？)
• 用unique_ptr<OpenGLContext> m_opengl;而不是OpenGLContext m_opengl;.
  然后初始化为m_opengl(),在c'tor体中调用SetPixelFormat()并使用m_opengl.reset(new OpenGLContext);
• SetPixelFormat()来自DeviceContextc'tor的 电话

哪种解决方案更可取？为什么？我错过了什么？

我在Windows上使用Visual Studio 2010 Express,如果重要的话.

编辑:我最感兴趣的是在决定使用其中一种方法时所涉及的权衡.

• m_dummy() 不工作,即使它会显得不优雅
• unique_ptr<X>对我来说很有意思 …

构造函数和初始化列表之间的执行时间是否存在差异？(或者只是编码首选项的问题).我有一组需要经常创建的对象,并且想知道使用初始化列表而不是构造函数是否有任何性能提升.

如果我要创建一百万个A类实例和另一百万个B类实际选择会更好(这些对象代表网络中生成的数据包,因此这些数字).

 class A {
   private:
     int a, b;

   public:
     A(int a_var, int b_var):a(a_var), b(b_var) {}; 
 };

 class B {
   private:
     int a, b;

   public:
     B(int a_var, int b_var) {
        a = a_var;
        b = b_var;
     }
};

如果任何构造函数对于基本类型比其他构造函数更快(如示例中所示),如果a和b被类型替换,它会更快吗？

输入示例:

 class AType {
   private:
     string a, b;

   public:
     AType(string a_var, string b_var):a(a_var), b(b_var) {}; 
};

在Effective C++中,据说初始化列表中的数据元素需要按其声明的顺序列出.进一步说,对此的推理是数据元素的析构函数以其构造函数的相反顺序被调用.

但我只是看不出这可能是个问题......

在编写我的类时,我总是一个好孩子,用m_作为所有成员变量的前缀:

class Test {
    int m_int1;
    int m_int2;
public:
    Test(int int1, int int2) : m_int1(int1), m_int2(int2) {}
};

int main() {
    Test t(10, 20); // Just an example
}

然而,最近我忘记这样做了,最后写了:

class Test {
    int int1;
    int int2;
public:
    // Very questionable, but of course I meant to assign ::int1 to this->int1!
    Test(int int1, int int2) : int1(int1), int2(int2) {}
};

信不信由你,编译的代码没有错误/警告,并且分配正确!只有在检查我的代码之前进行最后检查时才意识到我做了什么.

我的问题是:为什么我的代码编译？在C++标准中是否允许这样的东西,还是仅仅是编译器聪明的情况？如果您想知道,我使用的是Visual Studio 2008