标签: member-initialization

我无法在另一个类的定义中声明具有常量参数的类的实例.

class Foo
{
    private:
        const int m_a, m_b;
    public:
        Foo(int a, int b) : m_a(a), m_b(b) {}
};

class Bar
{
    public:
        Foo foo1(1,2);
        Foo foo2(2,3);
};

从这里我得到错误:

"error: expected identifier before numeric constant"
"error: expected ',' or '...' before numeric constant"

是否可以使用成员初始化列表的默认参数？

Vector3::Vector3(double xI, double yI, double zI)
: x(xI=0), y(yI=0), z(zI=0)
{
}

即使您通过设置参数调用它,构造函数也始终将x,y和z设置为0.

当使用std :: vector的fill构造函数(任一形式)和C++ 11的类成员初始化功能时,以下代码无法编译(在clang/llvm 3.6下):

#include <vector>

class Foo
{
  std::vector<char> buf_(10); //compiler error!
  std::vector<std::vector<char>> buf2_(10, std::vector<char>(20)); //compiler error!

public:
  void Bar();
};

void Foo::Bar()
{
  std::vector<char> buf3_(10); //OK
  std::vector<std::vector<char>> buf4_(10, std::vector<char>(20));  //OK
}

我已经搜索了有关向量填充构造函数和类成员初始化的问题,但是已经空了.知道我错过了什么吗？

在许多文章和书籍中提出了许多C++编程最佳实践.以下是与C++类数据成员相关的子集:

1. 确保在使用对象之前对其进行初始化.
2. 确保所有构造函数初始化对象中的所有内容.
3. 在每个构造函数的初始化程序列表中初始化数据成员通常比在其主体中更有效.
4. 在初始化列表中,数据成员应按其声明的顺序列出.

考虑以下具有Qt类类型的数据成员的类:

class MyClass {
public:
    myClass();
    ~myClass();
private:
    int myInt;
    QString myQString;
    QList<QString> myQList;
    QHash<int, QString> myQHash;
    char * pChar;
};

通过应用上述最佳实践,构造函数代码如下所示:

MyClass::MyClass() :
    myInt(0),    // OK, primitive should be initialized.
    myQString(),    // Is this really needed?
    myQList(),     // Is this really needed?
    myQHash(),    // Is this really needed?
    pChar(NULL)    // OK, pointer should be initialized.
{
}

但是,我的印象是并非所有Qt类数据成员都需要初始化.但我不是百分百肯定的.一些开发人员认为,通过将所有数据成员放在初始化列表中,我们可以避免省略应该初始化的一些重要数据成员的初始化.但是,如果这是一个真正的问题,我宁愿为每个不需要初始化的数据成员添加注释行,例如:

MyClass::MyClass() :
    myInt(0), 
    //myQString(),
    //myQList(),
    //myQHash(),
    pChar(NULL) 
{
}

总而言之,我想知道何时应该初始化Qt类数据成员,何时不需要初始化,以及为什么.谢谢!

我开始学习C++中的嵌套类,我尝试了一个快速代码,我粘贴在这里看看嵌套类是如何工作的.但编译以一些我无法弄清楚的错误结束.

文件:check.cpp

class Outside{
    public:
        class Inside{
            private:
                int mInside;
            public:
                Inside(const int& x):mInside(x){}
        };
    private:
        Inside mOutside(20);
};

int main(void){
Outside o;
return 0;
}

我编译的错误 g++ -Wall -std=c++11 -o check.out check.cpp

check.cpp:12:25: error: expected parameter declarator
        Inside mOutside(20);
                        ^
check.cpp:12:25: error: expected ')'
check.cpp:12:24: note: to match this '('
        Inside mOutside(20);
                       ^

我需要在此错误背后提供一个很好的解释以及如何克服此错误.

介绍

让我们介绍这个简单的例子：

#include <cmath>

class X
{
public: // Members

    /// A ^ B + A
    int A;

    /// A ^ B + B
    int B;

public: // Specials

    X(
        const int & A,
        const int & B
    )
        : A(A)
        , B(B)
    {
        const auto Pow = static_cast<int>(std::pow(A, B));

        this->A += Pow;
        this->B += Pow;
    }
};

琐事

• 引入的类具有两个成员变量：A和B。
• 它们分别采用A ^ B + A和的价值A ^ B + B。
• 它们都共享通用的复杂初始化代码（假设std::pow是复杂的）。 …

首先,我希望这不是一个公开的.我是一名java程序员,现在改为c ++.在java中你可以这样做

 Object obj = new Object();

根据我的理解,你可以在c ++中做同样的事情(看看java中的obj如何只保存在变量中作为参考),如下所示:

Object* obj = new Object();

我的问题是:这个对象存活了多长时间？只要指针有效,它会活着吗？还有,这可能会成为一个对象的成员初始化吗？如果指针被保存为可变成员(直到你存储它的那个对象是破坏者),那么对象是否会存在？

Srry任何错别字.祝你有美好的一天!