二、面向对象基础

1. 类与对象

1.1 核心概念

类（Class）

• ​​定义​​：抽象描述具有共同特征和行为的对象模板
• ​​本质​​：代码复用的蓝图，定义数据（属性）与操作（行为）的集合
• ​​命名规范​​：大驼峰命名法（如 MobilePhone）

对象（Object）

• ​​定义​​：类的具体实例化实体
• ​​生命周期​​：创建到销毁的整个过程
• ​​内存分配​​：分为栈对象（自动释放）和堆对象（手动管理）

​​思考​​：对象是否可以脱离类存在？
不可以。类是对象的抽象模板，没有类定义的对象无法创建。

---

1.2 类的构成要素

// 手机类示例
class MobilePhone {
public:
    // 属性（成员变量）
    string brand;
    string model;
    int weight;

    // 行为（成员函数）
    void play_music() {
        cout << "来财，憋老仔" << endl;
    }
    
    void run_game() {
        cout << "无畏契约、LOL、CF、永杰物件、原神、梦幻西游、第五人格、三国杀、火影忍者、小鳄鱼爱洗澡、完蛋我被美女包围了、天天酷跑、森林冰火人、黑猴、狼人杀、腐蚀、三角洲、古墓丽影、塞尔达、王者荣耀、奇迹暖暖、逆战、dnf、cs" << endl;
    }
    
    void call() {
        cout << "给女神打，您拨打的电话正在通话中，请稍后在播" << endl;
    }
};

 

---

1.3 对象内存管理

栈对象 vs 堆对象

特性	栈对象	堆对象
​​创建方式​​	MobilePhone mp;	MobilePhone* mp = new MobilePhone;
​​生命周期​​	自动释放（离开作用域）	需手动delete释放
​​访问方式​​	. 操作符	-> 操作符
​​内存泄漏风险​​	无	高（需手动管理）

代码示例

// 栈对象示例
void stackExample() {
    MobilePhone mp;       // 栈内存分配
    mp.brand = "华为";
    mp.model = "遥遥领先";
    mp.weight = 500;
    
    cout << mp.brand << " " << mp.model << " " << mp.weight << endl;
    mp.play_music();
    mp.run_game();
    mp.call();
    // 函数结束时自动销毁
}

// 堆对象示例
void heapExample() {
    MobilePhone* mp = new MobilePhone;  // 堆内存对象
    mp->brand = "小米";
    mp->model = "mi6";
    mp->weight = 200;
    
    cout << mp->brand << " " << mp->model << " " << mp->weight << endl;
    mp->play_music();
    mp->run_game();
    mp->call();
    
    delete mp;   // 必须手动释放
    mp = nullptr;// 防止野指针
}

---

1.4 构造函数

构造函数规则表

特性	说明
​​命名规则​​	与类名完全一致
​​返回值​​	无返回值类型
​​自动调用时机​​	对象创建时（栈/堆）
​​默认构造​​	无参构造函数，未定义其他构造时自动生成

多样化构造方式

class PhoneBuilder {
private:
    string brand;
    string os;

public:
    // 默认构造
    PhoneBuilder() : brand("Unknown"), os("No OS") {}
    
    // 全参构造
    PhoneBuilder(string b, string o) : brand(b), os(o) {}
    
    // 参数默认值构造
    PhoneBuilder(string b, string o = "Android") {
        brand = b;
        os = o;
    }
};

// 使用示例
PhoneBuilder a;                    // 调用默认构造
PhoneBuilder b("Xiaomi", "MIUI");  // 全参构造
PhoneBuilder c("OPPO");            // 参数默认值构造

1.5 拷贝构造函数

浅拷贝 vs 深拷贝

类型	实现方式	内存风险	适用场景
​​浅拷贝​​	直接复制成员变量的值	高（指针共享）	简单数据类型
​​深拷贝​​	为新对象分配独立内存空间	低	包含动态内存对象

代码示例

// 浅拷贝（存在隐患）
class ShallowCopy {
private:
    int* data;
public:
    ShallowCopy(int val) { data = new int(val); }
    ~ShallowCopy() { delete data; }
};

// 深拷贝（安全实现）
class DeepCopy {
private:
    int* data;
public:
    DeepCopy(int val) { data = new int(val); }
    DeepCopy(const DeepCopy& other) { 
        data = new int(*other.data); 
    }
    ~DeepCopy() { delete data; }
};

1.6 析构函数

class ResourceHandler {
private:
    FILE* filePtr;
public:
    ResourceHandler(string path) {
        filePtr = fopen(path.c_str(), "r");
    }
    ~ResourceHandler() {
        if(filePtr) fclose(filePtr);  // 自动资源释放
    }
};

 

2. 封装

2.1 访问控制实践

class SecurePhone {
private:    // 仅类内可访问
    string secretCode;

public:     // 对外接口
    void setCode(string code) {
        if(code.length() == 6) secretCode = code;
    }
    
    string getCode() const {
        return "****-" + secretCode.substr(3,2);
    }
};

封装优势

1. 数据隐藏：防止非法访问
2. 接口统一：修改内部实现不影响外部调用
3. 逻辑解耦：分层架构的基础

---

3. 静态成员与作用域

3.1 静态成员变量

class Test {
public:
    static int sharedCounter;  // 类级共享
    Test() { sharedCounter++; }
};

int Test::sharedCounter = 0;  // 类外初始化

3.2 单例模式

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}
public:
    static Singleton* getInstance() {
        if(instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};
Singleton* Singleton::instance = nullptr;

4. 关键字与高级特性

4.1 const约束

class ImmutableData {
private:
    const int id;
public:
    ImmutableData(int id) : id(id) {}  // 初始化列表
    int getID() const { return id; }   // 常量成员函数
};

 4.2 this指针

class ChainCall {
private:
    int value;
public:
    ChainCall& add(int num) {
        this->value += num;  // 解决成员变量遮蔽
        return *this;        // 返回自身引用
    }
};