C++基础复习心得 8

1 构造函数的重载

• 构造函数的重载
  在一个类中可以定义多个构造函数版本，即构造函数允许被重载，只要每个构造函数的形参列表是唯一的。一个类的构造函数数量是没有限制的。一般地，不同的构造函数允许建立对象时用不同的方式来初始化数据成员。

• 构造函数重载举例

1 #include <iostream>
2 using namespace std;
3 class Point { //Point类表示平面上的点
4 public:
5 Point() { x=y=0; } //无参数的构造函数
6 Point(int a, int b) : x(a), y(b) { } //有参数的构造函数
7 void display() { cout<<"x="<<x<<",y="<<y<<endl; }
8 private:
9 int x,y; //坐标值
10 };
11 int main()
12 {
13 Point m; //定义Point对象m， 调用构造函数初始化
14 m.display(); //显示坐标
15 Point n(1,2); //定义Point对象n， 调用构造函数初始化
16 n.display(); //显示坐标
17 return 0;
18 }

尽管在一个类中可以包含多个构造函数，但是对于每一个对象来说，建立对象时只执行其中一个，并非每个构造函数都被执行。

2 带默认参数的构造函数

• 构造函数的参数允许使用默认值。
  对类的设计者来说，使用默认参数可以减少代码重复；对类的使用者者来说，使用默认参数可以方便地用适当的参数进行初始化。

• 带默认参数的构造函数举例

1 #include <iostream>
2 using namespace std;
3 class Point { //Point类表示平面上的点
4 public:
5 Point(int a=0,int b=0) : x(a),y(b) { }//带默认参数的构造函数
6 void display() { cout<<"x="<<x<<",y="<<y<<endl; }
7 private:
8 int x,y;   //坐标值
9 };
10 int main()
11 {
12 Point k,m(1),n(1,2); //定义Point对象k,m,n， 调用构造函数初始化
13 k.display(); m.display(); n.display(); //显示坐标
14 return 0;
15 }

• 关于构造函数默认参数的说明

  必须在类的内部指定构造函数的默认参数，不能在类外部指定默认参数

class Point {
public:
Point(int a,int b);
void display() { cout<<"x="<<x<<",y="<<y<<endl; }
private:
int x,y; //坐标值
};
Point::Point(int a=0,int b=0) //错误， 不能在类外指定默认参数
{
x=a; y=0;
}

如果构造函数的全部参数都指定了默认值，则在定义对象时可以给一个或几个实参，也可以不给出实参。这时，就与无参数的构造函数有歧义了：

class Point {
public:
Point(){x=y=0;}
Point(int a=1,int b=1):x(a),y(b) { };
void display() { cout<<"x="<<x<<",y="<<y<<endl; }
private:
int x,y; //坐标值
};
int main()
{
Point k; //出现歧义， 既可以x=0， y=0； 也可以x=1， y=1
return 0;
}

在一个类中定义了带默认参数的构造函数后不能再定义与之有冲突的重载构造函数。

一般地，不应同时使用构造函数的重载和带默认参数的构造函数。

3 定义默认构造函数

• 默认构造函数
  默认构造函数就是在没有显式提供初始化式时调用的构造函数，它
  是一个不带参数的构造函数。如果定义某个类的对象时没有提供初
  始化式就会使用默认构造函数。

  定义默认构造函数（ default constructor） 的一般形式为：

类名()
{
    函数体
}

它由不带参数的构造函数，或者所有形参均是默认参数的构造函数定义。与默认构造函数相对应的对象定义形式为：

类名  对象名;

任何一个类有且只有一个默认构造函数。如果定义的类中没有显式定义任何构造函数，编译器会自动为该类生成默认构造函数，称为合成默认构造函数（synthesized default constructor）。

一个类哪怕只定义了一个构造函数，编译器也不会再生成默认构造函数。换言之，如果为类定义了一个带参数的构造函数，还想要无参数的构造函数，就必须自己定义它。

一般地，任何一个类都应定义一个默认构造函数。因为，在很多情况下，默认构造函数是由编译器隐式调用的。

4 隐式类类型转换

• 隐式转换
  为了实现其他类型到类类型的隐式转换，需要定义合适的构造函数。可以用单个实参调用的构造函数（称为转换构造函数）定义从形参类型到该类类型的隐式转换。

• 隐式类类型转换举例

1 #include <iostream>
2 using namespace std;
3 class Data {        //Data类定义
4 public:
5     Data(const string& str="") : s1(str) { }
6     void SetString(const Data& r) //期待的是Data类型的对象
7     { s1=r.s1; }
8     void print() { cout<<s1<<endl; }
9 private:
10    string s1;
11};
12 
13int main()
14{
15    Data a,b,c("world");
16    string i="string";
17    a.SetString(c);
18    b.SetString(string("world")); //隐式转换
19    a.print(); b.print();
20    Data d=Data(i); //隐式转换
21    d.print();
22    return 0;
23}

• 使用单个参数的构造函数来进行类类型转换的方法可以总结如下：
  （1） 先声明一个类；
  （2） 在这个类中定义一个只有一个参数的构造函数，参数的类型
  是需要转换的数据类型，即转换构造函数的一般形式为：
  类名(const 指定数据类型& obj)
  （3） 采用转换构造函数定义对象时即进行类型转换，一般形式为：
  类名(指定数据类型的数据对象)

• 可以禁止由构造函数定义的隐式转换，方法是通过将构造函数声明
  为explicit，来防止在需要隐式转换的上下文中使用构造函数。

• C++关键字explicit用来修饰类的构造函数，指明该构造函数是显式的。explicit关键字只能用于类内部的构造函数声明上，在类定义外部不能重复它。

• 一般地，除非有明显的理由想要定义隐式转换，否则，单形参构造函数应该为explicit。将构造函数设置为explicit可以避免错误，如果真需要转换，可以显式地构造对象。

5 复制构造函数

• 复制构造函数

  1 复制构造函数又称为拷贝构造函数，它是一种特殊的构造函数。它的作用就是用一个已经生成的对象来初始化另一个同类的对象。
  2 变量的初始化：int a=10; int b=a;
  3 对象的初始化：Point pt1(10,20); Point pt2=pt1;

• 复制构造函数定义的一般形式为：

类名(const 类名& obj)
{
    函数体
}

class Point { //Point类
public:
    Point():x(0), y(0) { } //默认构造函数
    Point(const Point& r):x(r.x),y(r.y) { }//复制构造函数
    Point(int a,int b):x(a),y(b) { } //带参数构造函数
private:
    int x,y;
};