当前位置：首页 > news >正文

（C++）C++类和类的方法（基础教程）（与Python类的区别）

news 2025/7/31 20:53:51

前言：

本篇博客建议搭配：（Python）类和类的方法（基础教程介绍）（Python基础教程）-CSDN博客

一起学习使用；

源代码：

#include <iostream>
#include <string>using namespace std;class Student{protected:string name;int age;string sex;int credit;public:static string stats;Student(string n,int a,string s,int c):name(n),age(a),sex(s),credit(c){}virtual string tell(){return name+"说：你好";}string getName()const{return name;}int getAge()const{return age;}string getSex()const{return sex;}int getCredit()const{return credit;}
};string Student::stats="大学";class Teacher:public Student{private:int pay;public:static string stats;Teacher(string n,int a,string s,int p):Student(name,age,sex,0),pay(p){}string tell() override{return name+"说：我不好";}int getPay() const {return pay; }
};string Teacher::stats="教师";int main(){Student student("大炮", 21, "男", 10);cout << student.tell() <<endl;cout << Student::stats <<endl;cout << student.getCredit() <<endl;Teacher teacher("富贵", 55, "男", 10000);cout << teacher.tell() << endl;cout << Teacher::stats << endl;cout << teacher.getPay() << endl; cout << teacher.getName() << endl;cout << teacher.getCredit() << endl;return 0;
}

代码解析：

下面是完整的 C++ 实现，包含详细注释和与 Python 代码的对比说明：

#include <iostream>
#include <string>// 学生类 (基类)
class Students {
protected:  // protected 允许派生类访问成员std::string name;int age;std::string sex;int credit;public:// 类属性（静态成员变量）static std::string stats;  // 相当于 Python 的类属性// 构造函数（类似 Python 的 __init__）Students(std::string n, int a, std::string s, int c) : name(n), age(a), sex(s), credit(c) {}// 成员函数（方法）virtual std::string tell() {  // virtual 允许派生类重写return name + "说：你好";}// 访问器方法std::string getName() const { return name; }int getAge() const { return age; }std::string getSex() const { return sex; }int getCredit() const { return credit; }
};// 初始化静态成员变量（类属性）
std::string Students::stats = "大学";// 教师类（派生类）
class Teachers : public Students {
private:int pay;  // 教师特有属性public:// 类属性（重新定义）static std::string stats;  // 覆盖基类的类属性// 构造函数Teachers(std::string n, int a, std::string s, int p) : Students(n, a, s, 0), pay(p) {}  // 调用基类构造函数// 重写基类方法std::string tell() override {return name + "说：我不好";}// 访问器方法int getPay() const { return pay; }
};// 初始化派生类的静态成员变量
std::string Teachers::stats = "教师";int main() {// 创建学生对象（类似 Python 的实例化）Students student("大炮", 21, "男", 10);// 调用方法和访问属性std::cout << student.tell() << std::endl;    // 输出：大炮说：你好std::cout << Students::stats << std::endl;   // 输出：大学（类属性）std::cout << student.getCredit() << std::endl; // 输出：10// 创建教师对象Teachers teacher("富贵", 55, "男", 10000);// 调用方法和访问属性std::cout << teacher.tell() << std::endl;   // 输出：富贵说：我不好std::cout << Teachers::stats << std::endl;  // 输出：教师（派生类类属性）std::cout << teacher.getPay() << std::endl;  // 输出：10000// 访问继承的属性std::cout << teacher.getName() << std::endl;  // 输出：富贵std::cout << teacher.getCredit() << std::endl; // 输出：0（从基类继承）return 0;
}

关键概念解释

1. 类属性（静态成员变量）

// Python 等效代码
// class Students:
//     stats = "大学"// C++ 实现
class Students {
public:static std::string stats;  // 声明
};// 类外初始化
std::string Students::stats = "大学";

static 关键字创建类级别的变量（所有对象共享）
必须在类外单独初始化
通过 类名::变量名 访问（如 Students::stats）

2. 构造函数

// Python 等效
// def __init__(self, name, age, sex, credit):
//     self.name = name
//     ...// C++ 实现
Students(std::string n, int a, std::string s, int c) : name(n), age(a), sex(s), credit(c) {}  // 初始化列表

初始化列表 : name(n), ... 类似 Python 的属性赋值
最后的 {} 是必须的空函数体
更高效（直接初始化而非先默认构造再赋值）

3. 继承与重写

// Python 继承
// class Teachers(Students):// C++ 继承
class Teachers : public Students {  // 公有继承
public:// 重写方法std::string tell() override { ... }
};

: public Students 表示公有继承
override 关键字明确表示重写基类方法
派生类可以添加新成员（如 pay）

4. 访问控制

访问修饰符	类内	派生类	类外	Python 等效
`private`	✅	❌	❌	`__` 开头
`protected`	✅	✅	❌	`_` 开头
`public`	✅	✅	✅	无修饰符

5. 方法调用

// Python 方法调用
// student.tell()// C++ 方法调用
student.tell();

使用点运算符 . 调用方法
对象在栈上创建（自动内存管理）
不需要 Python 的显式 self 参数

输出结果

大炮说：你好
大学
10
富贵说：我不好
教师
10000
富贵
0

C++ 与 Python 类实现对比表

特性	Python	C++
类定义	`class ClassName:`	`class ClassName { ... };`
构造函数	`__init__(self, ...)`	`ClassName(...) { ... }`
继承	`class Child(Parent):`	`class Child : public Parent { ... }`
方法重写	直接定义同名方法	使用 `virtual` 和 `override`
类属性	类内直接定义	`static` 成员 + 类外初始化
访问控制	命名约定 (`_`, `__`)	关键字 (`public`, `private`)
对象创建	`obj = ClassName()`	`ClassName obj(...)`
内存管理	自动垃圾回收	手动管理或智能指针
`self`/`this`	显式 `self` 参数	隐式 `this` 指针
多文件	单文件	头文件(.h) + 实现文件(.cpp)

多说一句：

构造函数语法解析：为什么要用花括号？

Person(std::string n, int a) : name(n), age(a) {}

结构分解

构造函数声明：
```
Person(std::string n, int a)
```
- 方法名与类名相同（Person）
- 接收两个参数：字符串 n 和整数 a
成员初始化列表：
```
: name(n), age(a)
```
- 在构造函数体执行前初始化成员变量
- name(n)：将参数 n 的值赋给成员变量 name
- age(a)：将参数 a 的值赋给成员变量 age
空函数体：
```
{}
```
- 表示构造函数没有额外操作
- 即使为空也必须保留花括号 {}