C++面向对象(二)

上一小节中,我谈到了面向对象方面的基础知识,而这里,我将继续向下逐步深入讲解。这一节里包含的大致内容有:

  • 构造函数
  • 复制构造函数
  • 析构函数

构造函数

  • 成员函数的一种,名字与类名相同,可以有参数,但不能有返回值(void也不行)
  • 作用是对对象进行初始化,如给成员变量赋初值
  • 如果定义类时没写构造函数,则编译器会生成一个默认的无参构造函数
  • 对象生成时构造函数自动被调用,对象一旦生成,就再也不能在其上执行构造函数

一个类中可以有多个构造函数,参数个数或类型不同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <iostream>
#include <cstring>
using namespace std;

class Complex {
private:
double real,imag;
public:
Complex (double r);
Complex (double r,double i);
Complex (Complex c1,Complex c2); //定义了三个不同的构造函数
void Set (double r,double i); //普通成员函数,与构造函数的不同点在于它有返回值
};
Complex::Complex(double r,double i):real(r),imag(i) { } //使用初始化列表来初始化字段,与下面形式函数所起到的效果相同
Complex::Complex(double r) {
real=r; imag=0;
}
Complex::Complex(Complex c1,Complex c2); {
real=c1.real+c2.real;
imag=c1.imag+c2.imag;
}
int main() {
Complex c1(3),c2(1,0),c3(c1,c2);
//定义了三个对象,根据其中不同的参数个数和类型会调用不同的构造函数
//最后调用的结果分别是c1={3,0},c2={1,0},c3={4,0};
}

构造函数在数组中的使用

1
2
3
4
5
6
7
8
9
class Test   {
public:
Test(int n) { } //(1)
Test (int n,int m) { } //(2)
Test () { } //(3)
};
Test array1[3]={1,Test(1,2)}; //三个元素分别用(1)(2)(3)初始化
Test array2[3]={Test(2,3),Test(1,2),1}; //三个元素分别用(2)(2)(1)初始化
Test * pArray[3]={new Test(4),new Test(1,2)}; //指针有所不同,根据后面的初始化,在这里只生成了两个对象,*pArray[2]并未生成对象,*pArray[0],*pArray[1]分别用(1)(2)初始化

复制构造函数

  • 只有一个参数,即对同类对象的引用。
  • 形如X::X(X&)或X::X(const X &),后者能以常量对象作为参数。
  • 如果没有定义复制构造函数,那么编译器生成默认复制构造函数。默认的复制构造函数完成复制功能。

如果构造函数和复制构造函数都未定义,则系统会生成默认无参构造函数默认复制构造函数

1
2
3
4
5
6
class Complex   {
private:
double real,imag;
};
Complex c1; //调用默认无参构造函数
Complex c2(c1); // =>Complex c2=c1. 调用默认复制构造函数,完成复制功能

复制构造函数起作用的三种情况:

  • 当用一个对象去初始化同类的另一个对象时:
  • 如果某函数有一个参数是类A的对象,那么该函数被调用时,类A的复制构造函数将被调用。
  • 如果函数的返回值是类A的对象时,则函数返回时,A的复制构造函数被调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
using namespace std;

class Complex {
public:
int v;
Complex(int n):v(n) { }
Complex(const Complex&a) {
v=a.v; //完成复制功能
cout<<"Copy constructor called"<<endl;
}
};
Complex Func() { //该函数的返回值是Complex的对象,会调用复制构造函数
Complex a(4);
return a;
}
int main() {
cout<<Func().v<<endl;
return 0;
}

该程序需注意一点,有些编译器(例如Dev C++)出于执行效率的考虑,编译的时候进行了优化,函数返回值对象不用复制构造函数初始化,所以和预期结果不符,但我们要明白这不符合C++语言的标准。

析构函数

  • 成员函数的一种,在前面加“~”,没有参数和返回值
  • 一个类最多只有一个析构函数
  • 对象消亡时,会自动被调用,在对象消亡前做善后工作,释放分配的空间等
  • 定义类时没写析构函数,则编译器生成默认析构函数,默认析构函数不涉及释放用户申请的内存释放等清理工作

下面这个实例揭示了构造函数、析构函数和变量的生存期问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <iostream>
using namespace std;

class Demo {
int id;
public:
Demo(int i) {
id=i;
cout<<"id="<<id<<" Constructed"<<endl;
}
~Demo() {
cout<<"id="<<id<<" Destructed"<<endl;
}
};
Demo d1(1); //全局变量,在进入main函数前就已经形成,首先进行初始化
void Func() {
static Demo d2(2); //静态局部变量,它的消亡是在整个程序结束之时
Demo d3(3); //局部变量
cout<<"Func"<<endl;
}
int main() {
Demo d4(4); //局部变量
d4=6; //调用类型转换构造函数,定义一个临时对象来实现,转换完成后,需要析构掉临时对象
cout<<"main"<<endl;
{
Demo d5(5); //d5对象有一个作用域(离对象最近的一对花括号内的范围就是它的作用域),作用域也标志着它的生命周期,离开作用域后,对象就会消亡。
}
Func();
cout<<"main ends"<<endl;
return 0;
}

  • 运行结果:
-------------The End-------------