C++ primer plus--抽象和类

10 对象和类

面向对象编程（OOP）的特性：

• 封装
• 继承
• 多态

10.1 过程性编程和面向对象编程

10.2 抽象和类

（1）类的声明放在头文件中，具体定义放在源文件。

（2）使用类对象的程序可以直接访问公有部分，但只能通过公有成员函数访问私有成员。例如

（3）通常，数据成员放在私有部分，成员函数放在公有部分。典型的类声明格式如下：

class className
{
    private:
        data member declarations(声明)
    public:
        member function prototypes(原型)
};

10.3 类的构造函数和析构函数

（1）一般情况下，程序只能通过成员函数访问数据成员，因此需要设计合适的成员函数，才能将对象初始化。

（2）构造函数与类同名，且没有返回值。一般放在公有部分（也可私有）。

（3）构造函数的参数表示的不是类成员，而是赋给成员的值，因此，参数名不能与类成员相同。

Manager::Manager(const string& name, int age) 
{
    name = name;
    age = age;         
}

//为避免这种错误，一种常见的做法是在数据成员中使用 m_ 前缀

class Manager
{
    private:
        string m_name;
        int m_age;
    public:
    ……
};

（4）调用构造函数

• 显式调用

Manager A = Manager("aaa", 21);

• 隐式调用

Manager A("aaa", 21);

（5）默认构造函数

class testClass
{
    public:
        testClass();                    /* 无参默认构造函数 */
        testClass(int a=10,char b='c');    /* 默认构造函数，和上面的不能同时存在
        */
        testClass(int a, char b);        /* 构造函数 */
        
 
    private:
        int  m_a;
        char m_b;
};

1）默认构造函数是在未提供显式初始值时，用来创建对象的构造函数。默认构造函数主要是用来完成如下形式的初始化的：

testClass classA;       //注意没有括号

2）只有当没有定义任何构造函数时，编译器才会提供默认构造函数；

3）只要定义了构造函数，编译器就不会再提供默认构造函数了，所以为了防止出现 testClass a; 这样的错误，最好再手动定义一个默认构造函数。

4）定义默认构造函数有两种方式，如上述代码展示的，一是定义一个无参的构造函数，二是定义所有参数都有默认值的构造函数 ；

5）一个类只能有一个默认构造函数，也就是说上述两种方式不能同时出现，一般选择 testClass(); 这种形式的默认构造函数。

6）隐式调用默认构造函数时，没有圆括号。

testClass classA;    //隐式调用默认构造函数
testClass classA();  //定义了一个返回testClass类型的函数
testClass classA(1, "c");  //调用非默认构造函数

（6）析构函数

1）创建对象时，系统会自动调用构造函数完成初始化工作，同样的，销毁对象时，也会自动调用析构函数完成清理工作，如，内存释放、文件关闭等。

2）析构函数没有返回值，也没有参数，不能被重载，一个类只能有一个析构函数。

3）析构函数不需要显示调用，而是在销毁对象时自动执行。如果程序员没有提供析构函数，将由编译器隐式地声明默认构造函数。

10.4 this 指针

（1）this 指针是类的一个自动生成、自动隐藏的私有成员，它存在于类的非静态成员函数中，指向被调用函数所在的对象。全局仅有一个this指针，当一个对象被创建时，this指针就存放指向对象数据的首地址。它指向当前对象，通过它可以访问当前对象的所有成员。

示例：

#include <iostream>
using namespace std;

class Student{
public:
    void setname(char *name);
    void setage(int age);
    void setscore(float score);
    void show();
private:
    char *name;
    int age;
    float score;
};

void Student::setname(char *name){
    this->name = name;
}
void Student::setage(int age){
    this->age = age;
}
void Student::setscore(float score){
    this->score = score;
}
void Student::show(){
    cout<<this->name<<"的年龄是"<<this->age<<"，成绩是"<<this->score<<endl;
}

int main(){
    Student *pstu = new Student;
    pstu -> setname("李华");
    pstu -> setage(16);
    pstu -> setscore(96.5);
    pstu -> show();

    return 0;
}

注意：this 是指针，使用时通过 this->name 访问成员；解引用后，可直接 *(this).name 访问。

10.5 对象数组

10.6 类作用域

（1）作用域为类的常量

class Bakery
{
private:
    const int Months = 12;
    double costs[Months];
    .....
}

这样是不可行的，因为声明类只是描述了对象的形式，并没有创建对象。因此，在创建对象前，没有用于存储值的空间。

以下两种方法解决：

• 枚举： 在类声明中声明的枚举的作用域为整个类，因此可以用枚举为整型常量提供作用域为整个类的符号名称。

class Bakery
{
private:
    enum {Months = 12};
    double costs[Months];
}

注意，这种方式声明枚举并不会创建类数据成员。也就是说，所有对象中都不包含枚举。Months只是一个符号名称，在作用域为整个类的代码中遇到它时，编译器将用30来替换它。

• static关键字：

class Bakery
{
private:
    static const int Months = 12;
    double costs[Months];
    ...
}

这将创建一个名为Months的常量，该常量将于其他静态变量存储在一起，而不是存储在对象中。因此，只有这一个Months常量，被所有Bakery共享。

10.7 抽象数据类型