面向对象编程：C++类和对象的使用与实现

一、C++类和对象的概述

C++是一种面向对象的编程语言，它侧重于将现实世界中事物以及它们之间的关系，用模拟现实世界的方式进行抽象和描述，从而构建出更清晰、更易于维护的程序结构。

类(Class)是C++语言中的一个重要特征，它是一种封装了数据和行为的用户定义数据类型，可以看作是自定义数据类型的模板，将数据和方法组织在一起，在程序中调用方法，可以对数据进行操作。

对象(Object)是类的实例化，它是具有唯一标识、属性、行为的实体，是程序中类的使用者，通过对象可以访问类中的成员。

class Student{        // 类定义，包含类名、数据成员、成员函数以及访问控制
private:
    string name;
    int age;
public:
    void setAge(int a);      // 成员函数声明
    int getAge();            // 成员函数声明
};
void Student::setAge(int a){  // 成员函数定义
    age = a;
}
int Student::getAge(){         // 成员函数定义
    return age;
}
int main(){
    Student stu;            // 定义对象
    stu.setAge(18);         // 访问成员函数设置年龄
    int age = stu.getAge(); // 访问成员函数获取年龄
}

二、C++类和对象中的访问控制

封装性是面向对象编程的一个主要原则，它可以保护数据不被程序的其他部分随意更改，C++通过访问控制关键字private、protected、public来实现类中成员的保护和控制访问级别。

private：私有成员，只能在类的内部使用。

protected：受保护成员，只能在类及其子类中使用。

public：公共成员，可以在类的内部和外部使用。

class Student{
private:
    string name;      // 私有成员
protected:
    int age;          // 受保护成员
public:
    void setName(string n){ name = n; }
    string getName(){ return name; }
};
class Undergraduate : public Student{  // 继承Student类
public:
    void setAge(int a){ age = a; }     // 在子类中通过调用父类的受保护函数设置年龄
    int getAge(){ return age; }        // 在子类中通过调用父类的受保护函数获取年龄
};
int main(){
    Undergraduate ustu;
    ustu.setName("Tom");    // 调用公共成员函数设置name
    ustu.setAge(19);        // 调用受保护成员函数设置age
    string name = ustu.getName();   // 调用公共成员函数获取name
    int age = ustu.getAge();        // 在子类中通过调用父类的受保护函数获取年龄
}

三、C++类和对象中的构造和析构函数

构造函数和析构函数是C++类中两个最为重要的函数，它们分别在对象创建和销毁的时候被调用，可以对对象进行初始化和释放资源等操作。

构造函数：与类同名，没有返回类型，用来初始化对象的数据成员；如果程序员没有定义构造函数，编译器会自动生成一个默认构造函数，否则需要显式定义。

析构函数：与类同名，以“~”开头，没有返回类型，用来释放对象占用的资源；如果程序员没有定义析构函数，编译器会自动生成一个默认析构函数，否则需要显式定义。

class Student{
private:
    string name;
    int age;
public:
    Student();            // 默认构造函数
    Student(string n, int a);  // 带参数的构造函数
    ~Student();           // 析构函数
    void setName(string n){ name = n; }
    string getName(){ return name; }
};
Student::Student(){     // 实现默认构造函数
    name = "";
    age = 0;
}
Student::Student(string n, int a){   // 实现带参数的构造函数
    name = n;
    age = a;
}
Student::~Student(){    // 实现析构函数
    /* 释放资源 */
}
int main(){
    Student stu1;                 // 调用默认构造函数
    Student stu2("Tom", 18);      // 调用带参数的构造函数，初始化name和age
}

四、C++类和对象的静态成员

静态成员是一种特殊的成员，它不属于任何对象，而是属于整个类共享的。通过访问类名::成员名的方式来访问。

静态数据成员：静态的数据成员，与类的所有对象共用一个数据空间。

静态成员函数：静态的成员函数，与类的所有对象无关，只能访问静态数据成员和静态成员函数，不可以访问非静态成员。

class Student{
private:
    string name;
    int age;
    static int count;    // 静态数据成员
public:
    static void showCount();    // 静态成员函数
    Student();
    ~Student();
};
int Student::count = 0;    // 静态数据成员初始化
void Student::showCount(){    // 实现静态成员函数
    cout << "The total number of students is: "<< count << endl;
}
Student::Student(){    // 实现构造函数
    count++;
}
Student::~Student(){   // 实现析构函数
    count--;
}
int main(){
    Student stu1, stu2;
    Student::showCount();    // 调用静态成员函数
}

五、C++类和对象的拷贝构造函数和赋值运算符

拷贝构造函数和赋值运算符是C++类中的两个重要函数，用来在对象之间进行拷贝，构造出新的独立的对象。

拷贝构造函数：与类同名，它用于创建一个对象并将其初始化为另一个对象的副本；如果程序员没有定义拷贝构造函数，编译器会自动生成一个默认拷贝构造函数，否则需要显式定义。

赋值运算符：以“=”为符号，用于将另一个对象的值复制到已有对象中。如果程序员没有定义赋值运算符，编译器会自动生成一个默认赋值运算符，否则需要显式定义。

class Student{
private:
    string name;
    int age;
public:
    Student();
    Student(const Student& other);   // 拷贝构造函数
    Student& operator=(const Student& other);  // 赋值运算符
};
Student::Student(){    // 默认构造函数
    name = "";
    age = 0;
}
Student::Student(const Student& other){   // 拷贝构造函数
    name = other.name;
    age = other.age;
}
Student& Student::operator=(const Student& other){   // 赋值运算符
    if (this != &other){    // 判断是否为同一对象
        name = other.name;
        age = other.age;
    }
    return *this;
}
int main(){
    Student stu1, stu2;
    stu1 = stu2;    // 赋值运算符调用
    Student stu3 = stu2;    // 拷贝构造函数调用
}