构造函数初始化列表
推荐在构造函数初始化列表中进行初始化
构造函数的执行分为两个阶段
- 初始化段
- 普通计算段 函数体中的赋值,实际上内存已经分配好了
对象成员及其初始化
成员的构造顺序与初始化列表中的顺序无关,而与成员定义的顺序有关。如果成员类型是类类型,且该类型没有默认构造函数,则一定要放在初始化列表中
const成员、引用成员初始化
const成员,引用成员的初始化也只能放在构造函数的初始化列表中进行,上面中提到了,对象成员(对象所对应的类没有默认构造函数)的初始化,也只能在构造函数初始化列表中进行。
const对应的常量只是对类的某一对象是常量,
枚举对类的任何对象可以是常量
#include <iostream>
using namespace std;
// const成员的初始化只能在构造函数初始化列表中进行
// 引用成员的初始化也只能在构造函数初始化列表中进行
// 对象成员(对象所对应的类没有默认构造函数)的初始化,也只能在构造函数初始化列表中进行
class Object
{
public:
enum E_TYPE
{
TYPE_A = 100,
TYPE_B = 200
};
public:
Object(int num=0) : num_(num), kNum_(num), refNum_(num_)
{
//kNum_ = 100;
//refNum_ = num_;
cout<<"Object "<<num_<<" ..."<<endl;
}
~Object()
{
cout<<"~Object "<<num_<<" ..."<<endl;
}
void DisplayKNum()
{
cout<<"kNum="<<kNum_<<endl;
}
private:
int num_;
const int kNum_;
int& refNum_;
};
int main(void)
{
Object obj1(10);
Object obj2(20);
obj1.DisplayKNum();
obj2.DisplayKNum();
cout<<obj1.TYPE_A<<endl;
cout<<obj2.TYPE_A<<endl;
cout<<Object::TYPE_A<<endl;
return 0;
}
拷贝构造函数
功能:使用一个已经存在的对象来初始化一个新的同一类型的对象
声明:只有一个参数并且参数为该类对象的引用
如果类中没有说明拷贝构造函数,则系统自动生成一个缺省复制构造函数,作为该类的公有成员
Test t(10);
//Test t2(t); // 调用拷贝构造函数
Test t2 = t; // 等价于Test t2(t);
注意一定要是引用,因为如果不是引用就涉及实参初始化形参,要调用拷贝构造函数,出现递归调用
拷贝构造函数调用的几种情况
- 当函数的形参是类的对象,调用函数时,进行形参与实参结合时使用。这时要在内存新建立一个局部对象,并把实参拷贝到新的对象中。理所当然也调用拷贝构造函数。
- 当函数的返回值是类对象,函数执行完成返回调用者时使用。理由也是要建立一个临时对象中,再返回调用者。为什么不直接用要返回的局部对象呢?因为局部对象在离开建立它的函数时就消亡了,不可能在返回调用函数后继续生存,所以在处理这种情况时,编译系统会在调用函数的表达式中创建一个无名临时对象,该临时对象的生存周期只在函数调用处的表达式中。所谓return 对象,实际上是调用拷贝构造函数把该对象的值拷入临时对象。如果返回的是变量,处理过程类似,只是不调用构造函数。
#include "Test.h"
#include <iostream>
using namespace std;
void TestFun(const Test t)
{
}
void TestFun2(const Test& t)
{
}
Test TestFun3(const Test& t)
{
return t; //返回调用拷贝构造函数
}
const Test& TestFun4(const Test& t)
{
//return const_cast<Test&>(t);
return t; //不会调用拷贝构造函数
}
int main(void)
{
Test t(10);
//t = TestFun3(t); 临时对象进行拷贝赋值运算
//Test t2 = TestFun3(t); 不会进行拷贝赋值运算,临时对象被接管
//Test& t2 = TestFun3(t); 引用临时对象,临时对象不会马上销毁
//Test t2 = TestFun4(t); 会调用拷贝构造函数生成t2
const Test& t2 = TestFun4(t); 不会调用拷贝构造函数
cout<<"........"<<endl;
return 0;
}
深拷贝与浅拷贝
在没有提供拷贝构造函数时,系统会提供默认的拷贝函数,系统提供的默认拷贝构造函数是浅拷贝,各个成员进行赋值,但是当成员含义指针时涉及到动态内存的分配,如果涉及浅拷贝就会共享同一块内存,但是当一个对象释放时,另一个对象也会出现无效的状态,有可能出现同一块内存释放两次的情况。因此就要实施深拷贝,将指针指向的对象的值进行拷贝。
赋值操作
系统默认提供的赋值操作也是浅拷贝,各个成员进行赋值。因此也要实施深拷贝
禁止拷贝
将赋值与拷贝构造函数声明为私有,并不实现
空类默认产生的成员
class Empty {};
Empty(); // 默认构造函数
Empty( const Empty& ); // 默认拷贝构造函数
~Empty(); // 默认析构函数
Empty& operator=( const Empty& ); // 默认赋值运算符
Empty* operator&(); // 取址运算符
const Empty* operator&() const; // 取址运算符 const
简单实现string 实施深拷贝
#ifndef _STRING_H_
#define _STRING_H_
class String
{
public:
String(char* str="");
~String();
String(const String& other);
String& operator=(const String& other);
void Display();
private:
char* AllocAndCpy(char* str);
char* str_;
};
#endif // _STRING_H_
#include "String.h"
//#include <string.h>
#include <cstring>
#include <iostream>
using namespace std;
String::String(char* str/* = */)
{
str_ = AllocAndCpy(str);
}
String::~String()
{
delete[] str_;
}
String::String(const String& other)
{
str_ = AllocAndCpy(other.str_);
}
String& String::operator =(const String &other)
{
if (this == &other)
return *this;
delete[] str_;
str_ = AllocAndCpy(other.str_);
return *this;
}
char* String::AllocAndCpy(char* str)
{
int len = strlen(str) + 1;
char* tmp = new char[len];
memset(tmp, 0, len);
strcpy(tmp, str);
return tmp;
}
void String::Display()
{
cout<<str_<<endl;
}