如果初始化列表顺序与类中的变量顺序不匹配,为什么gcc会抛出一个合适的东西呢？
class myClass
{
public:
int A;
int B;
myClass();
};
myClass::myClass() :
B(1),
A(2)
{}
将导致:
file.h:274: warning: 'myClass::A' will be initialized after
file.h:273: warning: 'int myClass::B
file.cpp:581: warning: when initialized here
发出这种警告有什么具体原因吗？是否存在与初始化类变量相关的风险,其顺序与在类中定义的顺序不同？
(注意,有一个问题触及了这个主题,但答案几乎是"因为它应该是这样"而没有给出任何理由,为什么应该订购,或者这有什么不对的故障 - 我会想知道为什么存在这样的限制 - 有人会举例说明它可能适得其反吗？)
构造函数初始化列表中的执行顺序是否可确定？我知道成员中的成员顺序是这些成员初始化的顺序,但如果我有这样的场景:
class X()
{
X_Implementation* impl_;
};
and then providing that allocator is available:
X::X():impl_(Allocate(sizeof(X_Implementation)))//HERE I'M ALLOCATING <--1
,impl_(Construct<X_Implementation>(impl_))//AND HERE I'M CONSTRUCTING <--2
{
}
但为了使这个可靠,这个顺序必须是从左到右.它是由GREAT BOOK OF std保证还是不保证？如果不是,我总是可以将第二条线移动到身体中.
当C++类的多个const属性依赖于某些中间计算时,初始化它们的最简单方法是什么？
例如,如何更正下面类的构造函数？
class MyClass {
public:
const int a;
const int b;
MyClass() {
int relatedVariable = rand() % 250;
a = relatedVariable % 100;
b = abs(relatedVariable - 150);
}
};
可能重复:
构造函数初始化列表评估顺序
在为类编写C++构造函数时,为什么初始化成员字段的顺序应该是它们的声明顺序？
请考虑以下C++代码.在使用gcc(gcc -g -Wall foo.cpp)进行编译时,我收到了警告
g++ -g -Wall main.cpp
main.cpp: In constructor ‘myclass::myclass(int, int, int, int, int, int)’:
main.cpp:12: warning: ‘myclass::z’ will be initialized after
main.cpp:11: warning: ‘int myclass::y’
main.cpp:26: warning: when initialized here
这是代码.在此,成员z出现在构造函数类的初始化列表中,y并抛出上述警告.
#include <iostream>
#include <iomanip>
class myclass
{
public:
int x;
int y;
int z;
myclass(int num1, int num2, int num3, int num4, int num5, int num6);//constructor for the class
private:
int a;
int b;
int c;
};
myclass::myclass(int num1, …例如,Area()在这里打电话是否安全:
Polygon::Polygon( Coord x0, Coord y0, Coord x1, Coord y1 )
: m_BoundingBox( x0, y0, x1, y1 ), m_Area( m_BoundingBox.Area() )
{
}
也就是说,可以假设: ,构造函数部分中的成员按照列出的顺序构造和初始化吗？
1)如果我没有弄错,C++标准保证单个翻译单元中的静态变量按其定义顺序初始化.我对以下代码片段感到困惑:
extern int n;
int k = n;
int n = 2;
extern int n;是声明,而不是定义,所以k是之前定义的n,但是GCC,Clang和MSVC都告诉我k == 2全局变量初始化之后.对我来说,目前还不清楚如何k在之后分配2 int k = n;,因为n尚未在该点初始化,其值必须为零.
如果我们将最后一行更改为:
int n = func();
哪里func()是非constexpr,然后k将被指定为零,正如我所期望的那样.那么,在编译时初始化全局变量会改变初始化的顺序吗？
2)这是另一个代码片段:
class Base
{
public:
struct static_constructor
{
static_constructor()
{
i = 1;
}
};
static static_constructor constructor;
static int i;
};
Base::static_constructor Base::constructor;
int Base::i = 2;
当Base::constructor被定义,它的构造函数被调用,并i = 1进行分配.但是Base::i目前还没有定义,所以,请你解释一下此时发生了什么,为什么最后 …
c++ initialization global-variables static-variables static-members
以下是否有效？
class myClass
{
private:
...
int m_nDataLength;
boost::shared_array<int> m_pData;
...
public:
myClass(): ..., m_nDataLength(10), m_pData(new int[m_nDataLength]), ...
{
}
}
我是否正确地假设初始化将完全按照我在ctor中给出的顺序发生？如果没有,如果在m_pData之后m_nDataLength的初始化发生了怎么办？
c++ constructor memory-management smart-pointers initialization-list
我正在研究Michael J Laszlo的书" C++中的计算几何和计算机图形学 ".以下是模板类原型:
template <class T> class ListNode : public Node {
T _val;
ListNode (T val);
friend class List<T>;
};
template <class T> ListNode <T>::ListNode(T val)
{_val=val;};
template <class T> class List{
private:
ListNode <T> *header;
ListNode <T> *win;
int _length;
public:
List(void);
~List(void);
T insert(T);
T append(T);
List * append(List*);
T prepend(T);
T remove(void);
void val(T); // overloaded function!
T val(void);// overloaded function!
T next(void);
T prev(void);
T first(void);
T last(void);
int length(void);
bool …我想知道我是否正在使用以下的好方法:
下面的代码似乎有效,但我想知道我是否只是"幸运"编译器足够同情.
为清楚起见,我在下面的评论中添加了评论和我的问题.
谢谢 !
struct Foo
{
std::string mValue;
};
class B
{
public:
B(const Foo & foo) : mFoo_External(foo) {}
private:
const Foo & mFoo_External; //this is an external reference to the member
//(coming from A)
};
class A
{
public:
//Here is the big question
//Shall I use :
// A(const Foo & foo) : mFoo(foo), mB(mFoo) {}
// or the declaration below
A(const Foo & foo) : mFoo(foo), mB(foo) {}
private:
//According to my …我想知道构造函数按声明对象的顺序调用的原因.
我读了这个问题,但我没有把那里指定的原因作为评论.
说明理由是:
它们在成员声明顺序中而不是在构造函数中按顺序构造的原因是,可能有几个构造函数,但只有一个析构函数.析构函数以相反的构造顺序销毁成员.
有人可以解释一下吗？
考虑下面的课程
class A
{
int a;
double b;
float c;
A():a(1),c(2),b(3)
{}
}
我们是否必须按照我们在类中声明的顺序使用初始化列表中的变量？初始化列表中的变量顺序是否会对该类/变量的内存分配产生影响？(考虑一下场景,如果类有很多bool变量,很多双变量等等.)
在网站上还没有发现这个问题。假设我有两个类，其中一个类包含对另一个类的引用：
class ClassA {};
class ClassB
{
classA & r_classA;
public:
ClassB( ClassA & io_classA ):r_classA( io_classA ){}
};
因此，如果我想创建 ClassB 的实例，我必须在构造函数中向它传递对 classA 的引用：
int main()
{
ClassA classA;
ClassB classB ( classA );
return 0;
}
现在假设我创建了一个 ClassC 类来保存这两个：
class ClassC
{
ClassA m_classA;
ClassB m_classB;
public:
ClassC();
}
我的问题是，我可以指望在初始化列表中构造 m_classB 之前创建 m_classA 吗？也就是说，我可以这样做吗：
ClassC::ClassC()
: m_classA()
, m_classB( m_classA )
{}
这个标准符合吗？便携的？我需要采取任何特殊的预防措施吗？我已经在 ClassC 主体中的 m_classB 之前声明了 m_classA，并且编译器没有抛出任何警告。该程序似乎工作正常。我只是想检查一下我是否没有指望一些不可靠的行为会导致崩溃或奇怪的错误。