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

双叶836

1216人浏览 · 2025-07-30 20:54:17

双叶836 · 2025-07-30 20:54:17 发布

前言：

本篇博客建议搭配：（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
空函数体：
```
{}
```
- 表示构造函数没有额外操作
- 即使为空也必须保留花括号 {}