构造函数
构造函数
1构造函数定义：
每个类都定义了它的对象被初始化的方式，，类通过一个或者几个特殊的成员函数来控制其对象初始化的过程，这些函数叫做构造函数。
任务：初始化类对象的数据成员，无论何时只要有类的对象被创建，就会执行构造函数。
2构造函数的种类
分为有参、无参、拷贝构造函数（或者复制构造函数）
举例说明：
#include"iostream"
using namespace std;
class Example1
{
public:
// 1.无参数构造函数
// 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做。
// 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有
//一个这样的无参构造函数，则需要自己显示地写出来
Example1()
{
m_a = 0;
m_b = 0;
}
// 2.有参构造函数（也称重载构造函数）
// 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
// 例如：你还可以写一个 Example1( int num)的构造函数出来
// 创建对象时根据传入的参数不同调用不同的构造函数
Example1(int a, int b)
{
m_a = a;
m_b = b;
}
// 复制构造函数（也称为拷贝构造函数）拷贝构造函数的形参是本类的对象的引用
// 复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
// 若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数(执行浅拷贝)，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险
Example1(const Example1 &exam)
{
// 把exam 中的成员数据拷贝过来给自己初始化
m_a = exam.m_a;
m_b = exam.m_b;
}
// 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象
// 例如：下面将根据一个double类型的对象创建了一个Complex对象
Example1::Example1(int a)
{
m_a = a;
m_b = 0;
}
// 等号运算符重载
// 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建
// 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
Example1 &operator=(const Example1 &rhs)
{
// 首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回
if (this == &rhs)
{
return *this;
}
// 复制等号右边的成员到左边的对象中
this->m_a = rhs.m_a;
this->m_b = rhs.m_b;
// 把等号左边的对象再次传出
// 目的是为了支持连等 eg: a=b=c 系统首先运行 b=c
// 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)
return *this;
}
private:
int m_a;
int m_b;
};
3调用方式
1代码解读
void main()
{
// 调用了无参构造函数初始化
Example1 c1,c2;
// 调用一般构造函数，数据成员初值被赋为指定值
Example1 c3(1, 2);
// 也可以使用下面的形式
Example1 c3 = Example1(1, 2);
// 把c3的数据成员的值赋值给c1
// 由于c1已经事先被创建，故此处不会调用任何构造函数
// 只会调用 = 号运算符重载函数
c1 = c3;
// 调用类型转换构造函数
// 系统首先调用类型转换构造函数，将5创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1?
c2 = 5;
// 调用拷贝构造函数( 有下面两种调用方式)
Example1 c5(c2);
Example1 c4 = c2; // 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2
}
2拷贝构造函数在以下三种情况下会被调用：
a.当用类的一个对象去初始化该类的另一个对象时系统自动调用拷贝构造函数实现拷贝赋值。
int main()
{
Point A(1, 2);
Point B(A); //拷贝构造函数被调用
cout << B.GetX() << endl;
return 0;
}
b.若函数的形参为类对象，调用函数时，实参赋值给形参，系统自动调用拷贝构造函数。例如：
void fun1(Point p)
{
cout << p.GetX() << endl;
}
int main()
{
Point A(1, 2);
fun1(A); //调用拷贝构造函数
return 0;
}
c.当函数的返回值是类对象时，系统自动调用拷贝构造函数。例如：
Point fun2()
{
Point A(1, 2);
return A; //调用拷贝构造函数
}
int main()
{
Point B;
B = fun2();
return 0;
}
最后这种情况怎么调用的拷贝构造函数呢？对象A是局部对象，在fun2函数执行完就释放了，那怎么将它拷贝给对象B呢？编译器在执行B=fun2()时会创建一个临时的无名对象，在执行return A时实际上是调用了拷贝构造函数将A的值拷贝到了临时对象中，A就释放了，然后将临时对象的值再拷贝到对象B中。
3构造函数规则：
1)当类中没有定义任何一个构造函数时，C++编译器会提供无参构造函数和拷贝构造函数，
2）当类中提供了任意的非拷贝构造函数，C++不会提供默认的无参构造函数
3）当类中提供了拷贝构造函数时，C++编译器不会提供无参构造函数，
4）默认拷贝构造函数成员变量简单赋值，执行浅拷贝
再次总结，只要你写了构造函数，那么你必须用
4如果在Example1中有定义另一种类类型的数据时初始化列表
如果在Example1中有定义另一种类类型的数据，那么怎么初始化另一种类类型的数据呢？初始化顺序是什么样的？
class testA
{
public:
testA(int a)
{
m_a = a;
}
protected:
private:
int m_a;
};
class testB
{
//初始化列表的格式如下
//初始化的顺序是由前到后t1然后t2
public:
testB(int a) :t1(1), t2(2)//初始化列表
{
m_a = a;
}
private:
int m_a;
testA t1;
testA t2;
};
5深拷贝，浅拷贝
如果没有自定义复制构造函数，则系统会创建默认的复制构造函数，但系统创建的默认复制构造函数只会执行“浅拷贝”，即将被拷贝对象的数据成员的值一一赋值给新创建的对象，若该类的数据成员中有指针成员，则会使得新的对象的指针所指向的地址与被拷贝对象的指针所指向的地址相同，delete该指针时则会导致两次重复delete而出错。
6析构顺序
#include <iostream>
using namespace std;
class Complex
{
private:
double m_real;
double m_imag;
int id;
static int counter;
public:
// 无参数构造函数
Complex(void)
{
m_real = 0.0;
m_imag = 0.0;
id = (++counter);
cout << "Complex(void):id=" << id << endl;
}
// 一般构造函数（也称重载构造函数）
Complex(double real, double imag)
{
m_real = real;
m_imag = imag;
id = (++counter);
cout << "Complex(double,double):id=" << id << endl;
}
// 复制构造函数（也称为拷贝构造函数）
Complex(const Complex & c)
{
// 将对象c中的数据成员值复制过来
m_real = c.m_real;
m_imag = c.m_imag;
id = (++counter);
cout << "Complex(const Complex&):id=" << id << " from id=" << c.id << endl;
}
// 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象
Complex(double r)
{
m_real = r;
m_imag = 0.0;
id = (++counter);
cout << "Complex(double):id=" << id << endl;
}
~Complex()
{
cout << "~Complex():id=" << id << endl;
}
// 等号运算符重载
Complex &operator=(const Complex &rhs)
{
if (this == &rhs) {
return *this;
}
this->m_real = rhs.m_real;
this->m_imag = rhs.m_imag;
cout << "operator=(const Complex&):id=" << id << " from id=" << rhs.id << endl;
return *this;
}
};
int Complex::counter = 0;
Complex test1(const Complex& c)
{
return c;
}
Complex test2(const Complex c)
{
return c;
}
Complex test3()
{
static Complex c(1.0, 5.0);
return c;
}
Complex& test4()
{
static Complex c(1.0, 5.0);
return c;
}
int main()
{
Complex a, b;
// 下面函数执行过程中各会调用几次构造函数，调用的是什么构造函数？
Complex c = test1(a);
Complex d = test2(a);
b = test3();
b = test4();
Complex e = test2(1.2);
Complex f = test1(1.2);
Complex g = test1(Complex(1.2));
}
浙公网安备 33010602011771号