022 C++的OOP技术

作者Lou Xiao, deepseek创建时间2025-04-02 16:26:53更新时间2025-04-02 16:26:53

一、OOP核心概念

1.1 四大特性

封装（Encapsulation）
- 数据隐藏：通过访问修饰符（private/protected/public）控制成员可见性
- 类与结构的区别：默认访问权限不同（class-private，struct-public）
继承（Inheritance）
- 代码复用和层次化设计
- 继承类型：public/protected/private
多态（Polymorphism）
- 编译时多态：函数重载、运算符重载
- 运行时多态：虚函数机制
抽象（Abstraction）
- 接口与实现分离
- 纯虚函数和抽象类

1.2 类与对象

 1.双击鼠标左键复制此行；2.单击复制所有代码。 
                                
                            class Circle {
                        
                            private:
                        
                                double radius;  // 数据成员封装
                        
                            public:
                        
                                // 构造函数
                        
                                Circle(double r) : radius(r) {}
                        
                                // 成员函数
                        
                                double area() const { 
                        
                                    return 3.14159 * radius * radius; 
                        
                                }
                        
                            };

二、类成员详解

2.1 构造函数与析构函数

构造函数重载
初始化列表语法
拷贝构造函数（深拷贝 vs 浅拷贝）
移动构造函数（C++11）
虚析构函数的重要性

2.2 特殊成员

const成员函数
static成员
友元（friend）
破坏封装性的特殊机制
友元函数/友元类

 1.双击鼠标左键复制此行；2.单击复制所有代码。 
                                
                            class Counter {
                        
                              static int count;  // 类级别共享
                        
                            public:
                        
                              Counter() { ++count; }
                        
                              static int getCount() { return count; }
                        
                            };

三、继承体系

3.1 继承类型

继承方式	基类public成员	基类protected成员	基类private成员
public	public	protected	不可访问
protected	protected	protected	不可访问
private	private	private	不可访问

3.2 多重继承

菱形继承问题
虚继承解决方案

 1.双击鼠标左键复制此行；2.单击复制所有代码。 
                                
                            class A {};
                        
                            class B : virtual public A {};
                        
                            class C : virtual public A {};
                        
                            class D : public B, public C {};

3.3 覆盖与隐藏

使用override关键字（C++11）
名字隐藏现象及解决方法

四、多态实现

4.1 虚函数机制

虚函数表（vtable）原理
动态绑定实现原理
final关键字（C++11）

4.2 抽象类与接口

 1.双击鼠标左键复制此行；2.单击复制所有代码。 
                                
                            class Shape {
                        
                            public:
                        
                                virtual double area() const = 0;  // 纯虚函数
                        
                                virtual ~Shape() = default;
                        
                            };
                        
                            class Square : public Shape {
                        
                                double side;
                        
                            public:
                        
                                double area() const override { 
                        
                                    return side * side; 
                        
                                }
                        
                            };

4.3 RTTI（运行时类型识别）

typeid运算符
dynamic_cast运算符

五、高级OOP特性

5.1 运算符重载

成员函数重载 vs 友元函数重载
特殊运算符（=, [], ->, ()）的重载规则

5.2 对象语义

拷贝语义
移动语义（C++11）
cpp class Buffer { int* data; public: // 移动构造函数 Buffer(Buffer&& other) noexcept : data(other.data) { other.data = nullptr; } };

5.3 RAII范式

资源获取即初始化
智能指针应用（unique_ptr, shared_ptr）

六、设计模式与OOP

6.1 常用模式实现

工厂模式
单例模式
观察者模式
策略模式

6.2 SOLID原则

单一职责原则
开闭原则
里氏替换原则
接口隔离原则
依赖倒置原则

七、最佳实践与陷阱

7.1 常见问题

对象切片（Object Slicing）
虚函数默认参数问题
异常安全与构造函数

7.2 性能考量

虚函数调用开销
对象内存布局优化
内联函数的使用

八、C++ OOP发展

8.1 现代C++特性

默认/删除函数（=default, =delete）
右值引用与完美转发
类型推导（auto, decltype）

8.2 元编程与OOP

模板与继承的结合
CRTP（Curiously Recurring Template Pattern）

文章目录

1	class Circle {
2	private:
3	double radius; // 数据成员封装
4	public:
5	// 构造函数
6	Circle(double r) : radius(r) {}
7
8	// 成员函数
9	double area() const {
10	return 3.14159 * radius * radius;
11	}
12	};

1	class Counter {
2	static int count; // 类级别共享
3	public:
4	Counter() { ++count; }
5	static int getCount() { return count; }
6	};

1	class A {};
2	class B : virtual public A {};
3	class C : virtual public A {};
4	class D : public B, public C {};

1	class Shape {
2	public:
3	virtual double area() const = 0; // 纯虚函数
4	virtual ~Shape() = default;
5	};
6
7	class Square : public Shape {
8	double side;
9	public:
10	double area() const override {
11	return side * side;
12	}
13	};