C++类与对象的详细说明2

1. 构造函数和析构函数

1.1 构造函数

构造函数是一种特殊的成员函数，它会在对象被创建时自动调用。构造函数可以用来初始化类的成员变量，或进行一些必要的初始化操作。在C++中，类可以拥有多个构造函数，这些构造函数的名称与类名相同，但可以拥有不同的参数列表。

下面是一个简单的示例代码，展示了如何声明和定义一个构造函数：

class Person {
  public:
    Person(string name, int age);  // 声明构造函数
  private:
    string name;
    int age;
};

Person::Person(string n, int a) {  // 定义构造函数
    name = n;
    age = a;
}

1.2 析构函数

与构造函数相反，析构函数会在对象被销毁时自动调用，用于释放对象占用的资源（比如动态分配的内存等）。析构函数的名称与类名相同，但前面要加上一个波浪号“~”。

下面是一个简单的示例代码，展示了如何声明和定义一个析构函数：

class Person {
  public:
    Person(string name, int age);
    ~Person();  // 声明析构函数
  private:
    string name;
    int age;
};

Person::~Person() {  // 定义析构函数
    // 对象被销毁时执行的代码
}

2. 访问控制

C++类中有三个访问控制关键字：public、private和protected。它们控制类的成员变量和成员函数对于外部的可见性和可访问性。

2.1 public

public成员可以被类的外部和内部代码访问，包括成员函数和非成员函数。这意味着它们可以从任何地方访问，不论是类的内部还是外部。通常，public成员用于类的接口，可以被其他代码使用。

下面是一个简单的示例代码，展示了如何使用public成员：

class Person {
  public:
    string name;  // 声明public成员
    int age;

    void display() {  // 声明public成员函数
        cout << "Name: " << name << endl;
        cout << "Age: " << age << endl;
    }
};

int main() {
    Person person;
    person.name = "Alice";  // 可以直接访问public成员
    person.age = 20;
    person.display();  // 可以调用public成员函数
    return 0;
}

2.2 private

private成员只能够被类的内部代码所访问，包括成员函数。这意味着它们不能被类的外部代码使用。通常，private成员用于类的实现，可以隐藏代码的细节。

下面是一个简单的示例代码，展示了如何使用private成员：

class Person {
  public:
    void setName(string n) {  // 声明public成员函数
        name = n;  // 可以访问private成员
    }
    void display() {  // 声明public成员函数
        cout << "Name: " << name << endl;  // 可以访问private成员
        cout << "Age: " << age << endl;  // 可以访问private成员
    }
  private:
    string name;  // 声明private成员
    int age;
};

int main() {
    Person person;
    person.setName("Alice");  // 可以调用public成员函数来访问private成员
    person.display();
    return 0;
}

2.3 protected

protected成员可以被类的内部代码和派生类的成员函数访问，但不能被类的外部代码使用。派生类是指由这个类派生出来的子类。通常，protected成员用于实现继承。

下面是一个简单的示例代码，展示了如何使用protected成员：

class Person {
  protected:
    string name;  // 声明protected成员
    int age;
};

class Student : public Person {  // 通过public继承Person类
  public:
    void setName(string n) {  // 声明public成员函数
        name = n;  // 可以访问protected成员
    }
    void display() {  // 声明public成员函数
        cout << "Name: " << name << endl;  // 可以访问protected成员
        cout << "Age: " << age << endl;  // 可以访问protected成员
    }
};

int main() {
    Student student;
    student.setName("Alice");  // 可以访问protected成员
    student.display();
    return 0;
}

3. 继承

继承是C++面向对象编程的重要特性之一，它允许子类（派生类）获取父类（基类）的成员变量和成员函数。派生类可以直接使用父类的成员，也可以重写或添加自己的成员。在C++中，继承有三种类型：公有继承、私有继承和保护继承。

3.1 公有继承

公有继承允许派生类的成员函数和外部函数访问父类的公有成员。当派生类继承父类时，需要在类名后面加上一个冒号“:”，然后跟上继承类型和父类的名称。公有继承的继承类型是public。

下面是一个简单的示例代码，展示了如何使用公有继承：

class Animal {  // 定义Animal类
  public:
    void eat() {  // 声明public成员函数
        cout << "Animal is eating\n";
    }
};

class Dog : public Animal {  // 定义Dog类并公有继承Animal类
  public:
    void bark() {  // 声明public成员函数
        cout << "Dog is barking\n";
    }
};

int main() {
    Dog dog;
    dog.eat();  // 可以访问Animal类的公有成员函数
    dog.bark();
    return 0;
}

3.2 私有继承

私有继承允许派生类的成员函数访问父类的私有成员，但外部函数不能访问。当派生类继承父类时，需要在类名后面加上一个冒号“:”，然后跟上继承类型和父类的名称。私有继承的继承类型是private。

下面是一个简单的示例代码，展示了如何使用私有继承：

class Animal {  // 定义Animal类
  private:
    int age;  // 声明私有成员
  public:
    Animal(int a) {  // 声明构造函数
        age = a;
    }
};

class Dog : private Animal {  // 定义Dog类并私有继承Animal类
  public:
    Dog(int a) : Animal(a) {  // 构造函数的代码中需要调用父类的构造函数
    }
    void bark() {  // 声明public成员函数
        cout << "Dog is barking\n";
    }
};

int main() {
    Dog dog(2);
    dog.bark();
    return 0;
}

3.3 保护继承

保护继承允许派生类和父类的成员函数访问父类的保护成员，但外部函数不能访问。当派生类继承父类时，需要在类名后面加上一个冒号“:”，然后跟上继承类型和父类的名称。保护继承的继承类型是protected。

下面是一个简单的示例代码，展示了如何使用保护继承：

class Animal {
  protected:
    string name;  // 声明保护成员
    void setName(string n) {  // 声明保护成员函数
        name = n;
    }
};

class Dog : protected Animal {  // 定义Dog类并保护继承Animal类
  public:
    void setName(string n) {  // 声明public成员函数来调用保护成员函数
        Animal::setName(n);
    }
    void bark() {  // 声明public成员函数
        cout << name << " is barking\n";  // 可以访问保护成员
    }
};

int main() {
    Dog dog;
    dog.setName("Tom");  // 可以调用public成员函数来访问保护成员
    dog.bark();
    return 0;
}