C++：类和对象的基本概念

一、类和对象是面向对象编程的两个基本概念。

1. 类（Class）：

   • 类是一种用户定义的数据类型，它包含了数据成员和操作这些数据的函数成员（也称为方法）。
   • 类是对象的模板或蓝图，描述了对象的属性（数据成员）和行为（函数成员）。
   • 类的定义通常包括公有（public）、私有（private）和保护（protected）三种访问级别，用于控制成员的访问权限。

2. 对象（Object）：

   • 对象是类的实例，通过类创建的实际实体。
   • 对象具有状态（由数据成员决定）和行为（由函数成员决定）。
   • 创建对象的过程称为实例化，通常使用new关键字或直接声明变量来完成。

下面是一个简单的C++类的示例，以及如何创建和使用该类的对象：

#include <iostream>
using namespace std;

// 定义一个名为Person的类
class Person {
public: // 公有成员可以在类的外部访问
    string name; // 数据成员
    int age;    // 数据成员

    // 函数成员（方法）
    void introduce() {
        cout << "Hello, my name is " << name << " and I am " << age << " years old." << endl;
    }
};

int main() {
    // 创建一个Person对象
    Person person1;

    // 设置对象的数据成员
    person1.name = "Alice";
    person1.age = 30;

    // 调用对象的方法
    person1.introduce(); // 输出： Hello, my name is Alice and I am 30 years old.

    return 0;
}

运行结果：

在上面的例子中，我们定义了一个Person类，包含两个数据成员name和age，以及一个函数成员introduce。然后，我们在main函数中创建了一个Person对象person1，设置了它的数据成员，并调用了它的introduce方法。

 二、C++类中的成员权限

C++类的三种成员访问权限是public、private和protected。下面是它们的基本区别和用法的表格：

访问权限	描述	在类的内部或外部可访问性	继承的子类可访问性	外部对象可访问性
public	公有成员，无限制访问	内部、外部、子类	是	是
private	私有成员，仅限类内部访问	仅内部	否	否
protected	受保护成员，类内部和子类可访问	内部、子类	是	否

详细说明：

• 公有成员 (public)

  • 可以在类的任何地方以及类的外部被访问。
  • 可以从任何继承该类的子类中被访问。
  • 通常用于提供接口，如构造函数、析构函数以及其他需要外部访问的方法和属性。

• 私有成员 (private)

  • 只能在类的内部被访问。
  • 不能从类的外部或者继承该类的子类中直接被访问。
  • 用于隐藏实现细节，确保数据的封装性和安全性。

• 受保护成员 (protected)

  • 可以在类的内部以及继承该类的子类中被访问。
  • 不可以从类的外部直接被访问。
  • 用于在继承关系中向子类提供有限的访问权限，同时对外部保持隐藏。

下面是一个示例代码来展示这三种访问权限：

#include <iostream>
using namespace std;

class MyClass {
public:
    int publicVar; // 公有变量

    void publicMethod() { // 公有方法
        cout << "This is a public method." << endl;
    }

private:
    int privateVar; // 私有变量

    void privateMethod() { // 私有方法
        cout << "This is a private method." << endl;
    }

protected:
    int protectedVar; // 受保护变量

    void protectedMethod() { // 受保护方法
        cout << "This is a protected method." << endl;
    }
};

class SubClass : public MyClass { // 继承自MyClass的子类
public:
    void accessMembers() {
        publicVar = 10; // 可以访问公有成员
        // privateVar = 20; // 错误！不能访问私有成员
        protectedVar = 30; // 可以访问受保护成员
        publicMethod(); // 可以调用公有方法
        // privateMethod(); // 错误！不能调用私有方法
        protectedMethod(); // 可以调用受保护方法
    }
};

int main() {
    MyClass myObj;
    myObj.publicVar = 5; // 可以访问公有成员
    // myObj.privateVar = 6; // 错误！不能访问私有成员
    // myObj.protectedVar = 7; // 错误！不能访问受保护成员
    myObj.publicMethod(); // 可以调用公有方法
    // myObj.privateMethod(); // 错误！不能调用私有方法
    // myObj.protectedMethod(); // 错误！不能调用受保护方法

    SubClass subObj;
    subObj.accessMembers(); // 在子类中可以访问受保护和公有成员，但不能访问私有成员

    return 0;
}

在上面的代码中，我们定义了一个名为ExampleClass的类，它包含公有、私有和受保护成员。然后我们定义了一个继承自ExampleClass的子类SubClass，并在其中尝试访问不同的成员。最后，在main函数中创建了ExampleClass和SubClass的对象，并展示了哪些成员可以从哪里访问。