C++类成员冒号初始化以及构造函数内赋值

最新推荐文章于 2023-03-06 14:20:47 发布

QQ_Fighting

最新推荐文章于 2023-03-06 14:20:47 发布

阅读量581

点赞数

分类专栏： C++基础

C++基础专栏收录该内容

4 篇文章 0 订阅

订阅专栏

转载自：http://blog.csdn.net/zj510/article/details/8135556

通常我们对类成员进行“初始化”有两种方式：

1. 构造函数后面跟冒号；

2. 构造函数里面对成员进行赋值。

有些人不太注意这个小细节，或者根本不知道他们的区别，认为两种方式是一样的。这个误解有时可能会对程序带来影响，这里我来介绍一下这两种方式。

首先我们看这么一段代码：

[cpp] view plain copy

print ?

class A
{
public:
A(int& c)
{
_a = 1;
}
protected:
int _a;
const int _b;
int& _c;
};

class A
{
public:
	A(int& c)
	{
		_a = 1;
	}
protected:
	int _a;
	const int _b;
	int& _c;
};

这段代码正确吗？答案是否定，这段代码无法通过编译。我们会看到下面的编译错误

1>d:\study\myconsole\myconsole\myconsole.cpp(14) : error C2758: 'A::_b' : must be initialized in constructor base/member initializer list
1> d:\study\myconsole\myconsole\myconsole.cpp(20) : see declaration of 'A::_b'
1>d:\study\myconsole\myconsole\myconsole.cpp(14) : error C2758: 'A::_c' : must be initialized in constructor base/member initializer list
1> d:\study\myconsole\myconsole\myconsole.cpp(21) : see declaration of 'A::_c'
意思是说成员_b和_c必须在构造函数的成员初始化列表里面初始化。那么_a为什么没有报错呢？看看成员的声明，我们看到_a是一个int类型，_b是一个const int类型，_c是一个int&类型。根据C++的规则，const类型和引用不可以被赋值，只能被初始化。这里我们先花一点点时间来看一下const类型和引用。

大家看看下面的这段代码是否正确：

[cpp] view plain copy

print ?

int _tmain(int argc, _TCHAR* argv[])
{
int a;
const int b;
int& c;
return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int a;
	const int b;
	int& c;

	return 0;
}

编译一下就会看到这2个错误：
1>d:\study\myconsole\myconsole\myconsole.cpp(30) : error C2734: 'b' : const object must be initialized if not extern
1>d:\study\myconsole\myconsole\myconsole.cpp(31) : error C2530: 'c' : references must be initialized

哦，原来const和引用必须在声明的时候就初始化（其实就是因为const和引用不可以在变量创建完成后再被赋值，所以编译器做了这个限制）。ok，把代码改一下：

[cpp] view plain copy

print ?

int _tmain(int argc, _TCHAR* argv[])
{
int a;
const int b=5;
int& c = a;
return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int a;
	const int b=5;
	int& c = a;

	return 0;
}

现在编译就没有问题了。细心的朋友会发现我这里在b和c声明代码那里使用的=号而不是(),其实我们也可以这么做：

[cpp] view plain copy

print ?

int _tmain(int argc, _TCHAR* argv[])
{
int a;
const int b(5);
int& c(a);
return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int a;
	const int b(5);
	int& c(a);

	return 0;
}

在这种情况下用括号和等于号初始化，效果是一样的。具体就不细讲了。

OK,我们举这个小例子的目的就是想加深大家对const和引用的印象：const和引用必须在声明的时候就初始化，换句话说就是在给const和引用类型变量分配内存的时候就初始化。

好了，现在我们回到class A的问题，类A里面有const成员和引用成员，当系统要给类A的对象分配内存的时候，系统需要给A的对象的3个成员_a, _b, _c分配内存。_a没有问题，系统直接给它一块内存。_b和_c就出问题了，分配内存的时候没有初始化。所以编译就出问题了。其实C++给类成员初始化的唯一方式就是成员初始化列表，也就是构造函数后面跟冒号的那种形式。将class A的代码调整一下：

[cpp] view plain copy

print ?

class A
{
public:
A(int& c): _b(2), _c(c)
{
_a = 1;
}
protected:
int _a;
const int _b;
int& _c;
};
int _tmain(int argc, _TCHAR* argv[])
{
int number = 3;
A a(number);
return 0;
}

class A
{
public:
	A(int& c): _b(2), _c(c)
	{
		_a = 1;
	}
protected:
	int _a;
	const int _b;
	int& _c;
};




int _tmain(int argc, _TCHAR* argv[])
{
	int number = 3;
	A a(number);

	return 0;
}

我们在A的构造函数的后面用冒号来初始化_b和_c。现在可以通过编译了。因为系统可以在给_b和_c分配内存的时候就初始化了。那么假如我们把代码改成下面的形式：

[cpp] view plain copy

print ?

class A
{
public:
A(int& c)
{
_a = 1;
_b = 2;
_c = c;
}
protected:
int _a;
const int _b;
int& _c;
};

class A
{
public:
	A(int& c)
	{
		_a = 1;
		_b = 2;
		_c = c;
	}
protected:
	int _a;
	const int _b;
	int& _c;

};

这样能行吗?编译一下就得到下面的错误：

这3个错误包含2个意思：

1. const和引用变量没有初始化；

2. 不可以对const变量_b进行赋值，也可以说const变量不可以当作左值（error C2166: l-value specifies const object）。

现在我们就可以知道了，其实在构造函数里面调用等于号并不是真正意义上的“初始化”。这个过程相当于：

1. 系统创建成员变量；

2. 创建完后再进行赋值操作。

而在构造函数后面跟冒号，就相当于：

1. 系统创建成员变量并且初始化。也就是系统为成员变量分配了一块内存并且把相应的数据给填了进去。而构造函数里面调用等于号的方式是分配好后再进行赋值，多了一个步骤。

下面我们再来做一个实验：

[cpp] view plain copy

print ?

class A
{
public:
A(int& c): _b(2), _c(c)
{
_a = 1;
}
protected:
int _a;
const int _b;
int& _c;
};
class B
{
public:
B(int& c):_objA(c)
{
printf("B constructor\n");
}
protected:
A _objA;
};
int _tmain(int argc, _TCHAR* argv[])
{
int number = 3;
B obj2(number);
return 0;
}

class A
{
public:
	A(int& c): _b(2), _c(c)
	{
		_a = 1;
	}
protected:
	int _a;
	const int _b;
	int& _c;

};

class B
{
public:
	B(int& c):_objA(c)
	{
		printf("B constructor\n");
	}

protected:
	A _objA;
};



int _tmain(int argc, _TCHAR* argv[])
{
	int number = 3;
	B obj2(number);

	return 0;
}

类B里面有个一个类A的对象，在类B的构造函数里面用冒号来初始化成员_objA。那么_objA是什么时候被初始化的呢？有图有真相：

从callstack里面可以清楚的看到：

1. 进入B的构造函数；

2. 进入A的构造函数。

也就是说冒号后面的代码是在一进入构造函数的时候就被调用了。

然后从左下角的Watch里面也可以看到，在系统调用构造函数括号里面的第一行代码之前，_a，_b, _c就已经分配好了。我们可以看到_a是个没有初始化过的值（系统自己生成了一个），_b和_c都是我们初始化的。那么我可以得出一个结论：

构造函数后面跟的冒号代码是在进入构造函数并且在括号里面的第一行代码之前被执行。

假如在B的构造函数里面不显式初始化_objA，会发生什么事呢？用代码模拟一下就知道了，系统会调用A的默认构造函数来初始化_objA。

好了，讲完了。通俗的讲，构造函数后面的冒号就是初始化，而括号里面的等于号并不是初始化，而是变量生成以后的赋值而已（永远都是2个步骤）。

附：

本文前面我提到一句话：const和引用不可以被赋值，只能被初始化。可能会有些朋友对这句话有意见，看下面的代码，这段代码是正确的，没有问题。那么怎么说不能被赋值呢？其实b=12只是把a的内容给改掉了（a和b的值都是12），而不是把引用b指向另外一个变量。换句话说：引用b初始化完成后，就永远指向初始化时候的那个变量，无法再改变了。我这里的“引用不可以被赋值”是指不能给引用本身赋值来改变它的指向，并不是说不可以改变引用指向的内存的内容。可能言语上面会有不同的理解，但是只要知道是这么回事情就可以了。

[cpp] view plain copy

print ?