C++的类 定义、构造函数、析构函数、初始化等（C++ Primer Plus 第10章笔记）

一、“类”的介绍

• "对象"是指现实世界中的一切事物
• 类可以看做是对相似事物的抽象

二、方法的定义

1. 在class内定义
2. 在class内声明，在class外定义

在类外定义成员函数通过在类内进行声明，然后在类外通过作用域操作符::进行实现，形式如下：

#include <iostream>

using namespace std;

class Point{
    public:
    	void setPoint(int x, int y); 	//在类内对成员函数进行声明
    	void printPoint();
    private:
    	int xPos;
    	int yPos;
};

void Point::setPoint(int x, int y){
    xPos = x;
    yPos = y;
}

void Point::printPoint(){
    cout<< "x = " << xPos << endl;
    cout<< "y = " << yPos << endl;
}

int main(){
    Point M;				//用定义好的类创建一个对象 点M
    M.setPoint(10, 20); 	//设置 M点 的x,y值
    M.printPoint(); 		//输出 M点 的信息
    return 0;

}

其中，Point::printPoint()是函数的限定名，printPoint()是函数的非限定名

三、类的初始化

构造函数中，变量初始化的顺序，是以变量定义的顺序来定的，而不是简单的以构造函数中变量出现的顺序来定的

#include "stdafx.h"
#include <iostream>
#include <string>

using namespace std;

class A{
	private:
    	int n1;
    	int n2;
	public:
    	A() :n2(34), n1(n2+1) {}
    	void Print() {
        	cout << "n1:" << n1 << ", n2: " << n2 << endl;
    	}
};

int main(){
    A a;
    a.Print();
    getchar();
    return 0;
}

上述代码中，初始化会按照声明时n1、n2的顺序赋值，

在class声明内部定义的函数默认为内联函数，class声明外定义的函数可加inline关键字定义为内联函数

---

下面两种写法是一个意思：
写法一：

public:
    A(int k1,int k2) {
        n1 = k1;
        n2 = k2;
}

---

写法二：

public:
    A(int k1,int k2) :n1(k1),n2(k2){}

类的构造函数和析构函数

构造函数：用于构造新对象、将值赋给它们的数据成员

特点：名称与类名相同，没有返回值且不声明为void

class stock{
    ...
};

stock::stock(...){
    ...
}

细节：形参命名时不要和类内变量名相同，解决方案：

class stu{
    int number;
    int score;
    public:
    	...
};

stu::stu(int num, int sco){				//另外取名
    ...
}

class stu{
    int m_number;						//加前缀"m_"
    int score_;							//加后缀"_"
    public:
    	...
};

构造函数的使用：

class stu{
	...
};

stu::stu(int num, int sco){
    ...
}

stu A = stu(003, 93);					//显式调用，会产生一个临时对象
stu B(004, 88);							//隐式调用，可能产生一个临时对象
stu *C = new stu(005, 73);

无法使用对象来调用构造函数，直接写stu(...)

C++中，未定义构造函数时，stu a;会被使用默认构造函数，不做任何工作。

若程序员定义了构造函数，则声明时必须初始化，除非构造函数有默认值（推荐）或使用函数重载新建无参数的构造函数。

如果在类定义中仅包含函数的声明，则默认的参数值应该放在声明中，而不能放在函数定义中

构造函数可用于初始化，也可用于赋新值。

• 只接收一个参数的构造函数可以直接通过赋值初始化，但不推荐：

stu::stu(int score){
	...
}

stu stu1 = 97;		// 不推荐

• 类构造函数初始化列表

Date::Date(int m,int d,int y):
  month(m),day(d),year(y) {}

Date::Date(int m,int d): month(m),day(d){
    year=2005;
}

有的时候必须用带有初始化列表的构造函数：

• 成员类型是没有默认构造函数的类。若没有提供显示初始化式，则编译器隐式使用成员类型的默认构造函数，若类没有默认构造函数，则编译器尝试使用默认构造函数将会失败。
• const 成员或引用类型的成员。因为 const 对象或引用类型只能初始化，不能对他们赋值。

C++ 初始化类成员时，是按照声明的顺序初始化的，而不是按照出现在初始化列表中的顺序。

补充：函数的声明

void a(int,int,int);	// 声明时

void a(int m=3,int n=8,int k=-8){
    ...
}

**考试重点：构造函数的调用顺序：**与对象生成的顺序一致，使用栈的原理

高级构造函数：

• 复制构造函数：以现成对象为基础，快速克隆多个相同的对象，参数为同类型的引用。

Date d3(d1);		//可以在没有写构造函数时调用默认构造函数
//当对象中包含成员中包含指针时，便需要自定义复制构造函数（深度复制）
//此时可以访问对象的私有成员
Date(Date &b){
    val = b.val;
}
Date(Date &b, int a=3){...}		//也是复制默认构造函数，因为除第一个参数外都有默认值

​ 当函数返回值为对象时会生成一个临时变量，然后用复制构造函数将return的对象赋值给这个临时变量

​ 若接受到的参数是基础类型的变量，则编译器

• 用于类型转换的构造函数：若接受到的参数是基础类型的变量，则编译器将此变量自动转换为对象。如何转换取决于是否有接受此类型的构造函数，并用一个临时对象代替这个参数。

析构函数：完成清理工作

若未使用new等，可以使用默认析构函数，什么也不做。

解析函数的原型：

~stu();
stu::~stu(){
    ...
}

自动变量在程序退出其定义所属代码块时消失，可自行添加大括号规定其范围。

列表初始化（C++11）

stu A={007, 97};

列表中元素应与构造函数的参数一一对应。

const成员函数

当对象为const或不希望对象中的值被修改时：

const stu A = {008, 66};
stu::show(...) const{		// 声明const成员函数
	...
}
// 若show不声明为const，则编译器会报错

四、this指针

用this指针指向自身的地址，用于涉及与其他对象共同的操作。

void Time::example(void){
	this->h = 3;
	this->m = 23;
}

五、对象数组

用构造函数对对象数组进行初始化（每个对象都会调用一次构造函数）：

stu students[4] ={
	stu(009, 86),
	stu(010, 87),
	stu(011)		// 可根据需要通过函数重载调用不同的构造函数
	// 剩余的对象将使用默认构造函数进行初始化
};

原理：先用默认构造函数初始化所有元素，然后用构造函数初始化临时对象，再将临时对象复制到对应对象中

六、类作用域

在类中定义的名称作用域为整个类

作用域为类的常量

    const int MONTHS = 12;      //错误，类未声明为对象时无空间，因此无效
    enum{months = 12};          //正确，可用months代替12
    static const int Months = 12;   //正确，会和其他静态变量放在一起，全局可用

• 作用域内枚举（C++11）

    enum class t_shirt {small, large};
    enum struct egg {small, large};
    //避免两个small矛盾，使用时egg::small。
    enum class : short pizza {small, large};
    //此语法指定枚举的底层类型为short类型