类的定义

类是C++面向对象编程的基本构建块，它将数据和操作数据的函数封装在一起。

类的基本语法

1
class 类名 {
2
    // 访问修饰符
3
private:
4
    // 私有成员（默认）
5
    
6
protected:
7
    // 受保护成员
8
    
9
public:
10
    // 公有成员
11
};

类的组成部分

数据成员（属性）

xxxxxxxxxx
6
1
class Student {
2
private:
3
    string name;    // 字符串类型的数据成员
4
    int age;        // 整型数据成员
5
    double score;   // 浮点型数据成员
6
};

成员函数（方法）

xxxxxxxxxx
21
1
class Rectangle {
2
private:
3
    double width;
4
    double height;
5
    
6
public:
7
    // 构造函数
8
    Rectangle(double w, double h) {
9
        width = w;
10
        height = h;
11
    }
12
    
13
    // 成员函数
14
    double getArea() {
15
        return width * height;
16
    }
17
    
18
    double getPerimeter() {
19
        return 2 * (width + height);
20
    }
21
};

访问修饰符

C++提供了三种访问修饰符来控制类成员的访问权限：

• private：私有成员，只能在类内部访问（默认）

• protected：受保护成员，可在类内部和派生类中访问

• public：公有成员，可在任何地方访问

xxxxxxxxxx
14
1
class Person {
2
private:
3
    string idNumber;  // 私有，只能在类内部访问
4
    
5
protected:
6
    string name;      // 受保护，可在派生类中访问
7
    
8
public:
9
    int age;          // 公有，可在任何地方访问
10
    
11
    void setIdNumber(string id) {
12
        idNumber = id;  // 可以访问私有成员
13
    }
14
};

对象创建

对象的创建是面向对象编程的基础操作。

栈上创建对象

栈上创建的对象会在超出作用域时自动销毁。

​x
1
class MyClass {
2
public:
3
    MyClass() { cout << "构造函数调用" << endl; }
4
    ~MyClass() { cout << "析构函数调用" << endl; }
5
};
6

7
void func() {
8
    MyClass obj;  // 在栈上创建对象
9
    // 函数结束时，obj自动销毁
10
}

堆上创建对象

堆上创建的对象需要手动释放内存。

xxxxxxxxxx
3
1
MyClass* ptr = new MyClass();  // 在堆上创建对象
2
// 使用对象...
3
delete ptr;  // 手动释放内存

构造函数

默认构造函数

xxxxxxxxxx
7
1
class Point {
2
public:
3
    int x, y;
4
    Point() { x = 0; y = 0; }  // 默认构造函数
5
};
6

7
Point p1;  // 调用默认构造函数

带参数的构造函数

xxxxxxxxxx
10
1
class Rectangle {
2
public:
3
    double width, height;
4
    Rectangle(double w, double h) {
5
        width = w;
6
        height = h;
7
    }
8
};
9

10
Rectangle rect(5.0, 3.0);  // 调用带参数的构造函数

初始化列表

xxxxxxxxxx
9
1
class Person {
2
private:
3
    string name;
4
    int age;
5
public:
6
    Person(string n, int a) : name(n), age(a) {}  // 使用初始化列表
7
};
8

9
Person person("张三", 25);

对象创建的其他方式

拷贝构造

xxxxxxxxxx
22
1
class MyString {
2
private:
3
    char* data;
4
public:
5
    // 构造函数
6
    MyString(const char* str) {
7
        data = new char[strlen(str) + 1];
8
        strcpy(data, str);
9
    }
10
    
11
    // 拷贝构造函数
12
    MyString(const MyString& other) {
13
        data = new char[strlen(other.data) + 1];
14
        strcpy(data, other.data);
15
    }
16
    
17
    ~MyString() { delete[] data; }
18
};
19

20
MyString s1("Hello");
21
MyString s2 = s1;  // 调用拷贝构造函数
22
MyString s3(s1);   // 也是调用拷贝构造函数

移动构造（C++11）

xxxxxxxxxx
25
1
class Vector {
2
private:
3
    int* data;
4
    size_t size;
5
public:
6
    // 构造函数
7
    Vector(size_t n) : size(n) {
8
        data = new int[size];
9
    }
10
    
11
    // 移动构造函数
12
    Vector(Vector&& other) noexcept : data(other.data), size(other.size) {
13
        other.data = nullptr;
14
        other.size = 0;
15
    }
16
    
17
    ~Vector() { delete[] data; }
18
};
19

20
Vector createVector() {
21
    Vector temp(100);
22
    return temp;  // 返回时可能触发移动构造
23
}
24

25
Vector v = createVector();  // 使用移动构造函数

列表初始化（C++11）

xxxxxxxxxx
8
1
class Point {
2
public:
3
    int x, y;
4
    Point(int x_val, int y_val) : x(x_val), y(y_val) {}
5
};
6

7
Point p1{10, 20};  // 列表初始化
8
Point p2 = {30, 40};  // 也是列表初始化

静态创建与动态创建的区别

对象数组的创建

xxxxxxxxxx
6
1
// 栈上创建对象数组
2
MyClass objArray[5];  // 调用默认构造函数5次
3

4
// 堆上创建对象数组
5
MyClass* ptrArray = new MyClass[5];  // 调用默认构造函数5次
6
delete[] ptrArray;  // 释放数组内存

对象销毁

对象的销毁是C++内存管理的重要环节，与对象创建相对应。

栈上对象的销毁

栈上创建的对象会在超出其作用域时自动销毁。

xxxxxxxxxx
4
1
void func() {
2
    MyClass obj;  // 在栈上创建对象
3
    // 函数结束时，obj自动销毁，调用析构函数
4
}  // 作用域结束，obj被销毁

堆上对象的销毁

堆上创建的对象需要手动释放内存。

xxxxxxxxxx
4
1
MyClass* ptr = new MyClass();  // 在堆上创建对象
2
// 使用对象...
3
delete ptr;  // 手动释放内存，调用析构函数
4
ptr = nullptr;  // 良好习惯：删除后将指针置空

析构函数

析构函数是对象销毁时自动调用的特殊成员函数，用于释放资源。

xxxxxxxxxx
15
1
class ResourceManager {
2
private:
3
    int* data;
4
    
5
public:
6
    ResourceManager() {
7
        data = new int[100];  // 分配资源
8
        cout << "资源分配" << endl;
9
    }
10
    
11
    ~ResourceManager() {
12
        delete[] data;  // 释放资源
13
        cout << "资源释放" << endl;
14
    }
15
};

对象销毁的顺序

局部对象

局部对象的销毁顺序与创建顺序相反（后进先出）。

xxxxxxxxxx
5
1
void func() {
2
    MyClass obj1;  // 首先创建
3
    MyClass obj2;  // 然后创建
4
    // obj2先销毁，然后obj1销毁
5
}

成员对象

类的成员对象销毁顺序与初始化顺序相反，与声明顺序无关。

xxxxxxxxxx
9
1
class Container {
2
private:
3
    ResourceA a;  // 首先初始化
4
    ResourceB b;  // 然后初始化
5
    
6
public:
7
    Container() {}
8
    ~Container() {}  // b先销毁，然后a销毁
9
};

继承关系中的对象

派生类对象销毁时，先调用派生类的析构函数，再调用基类的析构函数。

xxxxxxxxxx
11
1
class Base {
2
public:
3
    ~Base() { cout << "Base析构" << endl; }
4
};
5

6
class Derived : public Base {
7
public:
8
    ~Derived() { cout << "Derived析构" << endl; }
9
};
10

11
// 销毁Derived对象时，先调用Derived析构函数，再调用Base析构函数

虚析构函数

当通过基类指针删除派生类对象时，需要虚析构函数确保正确调用派生类的析构函数。

xxxxxxxxxx
19
1
class Base {
2
public:
3
    virtual ~Base() { cout << "Base析构" << endl; }
4
};
5

6
class Derived : public Base {
7
private:
8
    int* resource;
9
    
10
public:
11
    Derived() { resource = new int[10]; }
12
    ~Derived() override { 
13
        delete[] resource; 
14
        cout << "Derived析构" << endl; 
15
    }
16
};
17

18
Base* ptr = new Derived();
19
delete ptr;  // 正确调用Derived的析构函数，然后调用Base的析构函数

对象数组的销毁

xxxxxxxxxx
8
1
// 栈上对象数组的销毁
2
{
3
    MyClass objArray[5];  // 创建5个对象
4
}  // 作用域结束，按照创建的相反顺序销毁5个对象
5

6
// 堆上对象数组的销毁
7
MyClass* ptrArray = new MyClass[5];
8
delete[] ptrArray;  // 必须使用delete[]，而不是delete

拷贝构造函数

拷贝构造函数是C++中一种特殊的构造函数，用于创建一个对象的副本。它在对象需要复制时被调用，是C++中实现对象复制的重要机制。其形式为：

xxxxxxxxxx
1
1
ClassName(const ClassName& other);

其中other是同类型的另一个对象的引用，通常声明为常量引用。

调用时机

拷贝构造函数在以下情况下会被调用：

1. 用一个对象初始化另一个对象

   xxxxxxxxxx
   3
   1
   MyClass obj1;
   2
   MyClass obj2 = obj1;  // 调用拷贝构造函数
   3
   MyClass obj3(obj1);   // 也调用拷贝构造函数
   

2. 函数按值传递对象参数

   xxxxxxxxxx
   6
   1
   void func(MyClass obj) {  // 调用拷贝构造函数
   2
       // 函数体
   3
   }
   4
   
   5
   MyClass obj;
   6
   func(obj);  // obj被复制
   

3. 函数按值返回对象

   xxxxxxxxxx
   4
   1
   MyClass createObject() {
   2
       MyClass obj;
   3
       return obj;  // 调用拷贝构造函数（可能被优化）
   4
   }
   

默认拷贝构造函数

如果没有显式定义拷贝构造函数，编译器会提供一个默认的拷贝构造函数，执行浅拷贝（逐成员复制）。

xxxxxxxxxx
7
1
class Simple {
2
public:
3
    int value;
4
    string name;
5
    // 编译器生成的默认拷贝构造函数大致相当于：
6
    // Simple(const Simple& other) : value(other.value), name(other.name) {}
7
};

自定义拷贝构造函数

当类包含动态分配的资源时，需要自定义拷贝构造函数实现深拷贝。

xxxxxxxxxx
28
1
class DynamicArray {
2
private:
3
    int* data;
4
    int size;
5
    
6
public:
7
    // 普通构造函数
8
    DynamicArray(int sz) {
9
        size = sz;
10
        data = new int[size];
11
    }
12
    
13
    // 拷贝构造函数（深拷贝）
14
    DynamicArray(const DynamicArray& other) {
15
        size = other.size;
16
        data = new int[size];  // 分配新内存
17
        
18
        // 复制数据
19
        for (int i = 0; i < size; i++) {
20
            data[i] = other.data[i];
21
        }
22
    }
23
    
24
    // 析构函数
25
    ~DynamicArray() {
26
        delete[] data;
27
    }
28
};

浅拷贝与深拷贝

浅拷贝

• 简单地复制成员变量的值

• 对于指针成员，只复制指针值，不复制指针指向的内容

• 可能导致多个对象共享同一资源，引发"双重释放"问题

深拷贝

• 不仅复制成员变量的值，还为指针成员分配新内存并复制内容

• 确保每个对象拥有自己独立的资源

• 避免资源共享导致的问题

拷贝构造函数与赋值运算符的区别

xxxxxxxxxx
4
1
MyClass obj1;
2
MyClass obj2 = obj1;  // 拷贝构造函数（初始化）
3
MyClass obj3;
4
obj3 = obj1;          // 赋值运算符（赋值）

• 拷贝构造函数：创建新对象时调用

• 赋值运算符：已存在的对象间赋值时调用

禁用拷贝构造函数

在某些情况下，可能需要禁止对象的复制：

xxxxxxxxxx
12
1
class Uncopyable {
2
public:
3
    Uncopyable() {}
4
    
5
    // C++98/03方式：声明为私有但不定义
6
private:
7
    Uncopyable(const Uncopyable&);
8
    
9
    // C++11方式：使用delete关键字
10
public:
11
    Uncopyable(const Uncopyable&) = delete;
12
};

赋值运算符函数

赋值运算符函数是C++中的一种特殊成员函数，用于定义对象之间的赋值行为。它在已经存在的对象之间进行赋值操作时被调用。

赋值运算符函数的形式为：

xxxxxxxxxx
1
1
ClassName& operator=(const ClassName& other);

其中other是要赋值的源对象，返回类型通常是当前类的引用，以支持连续赋值。

默认赋值运算符

如果没有显式定义赋值运算符，编译器会提供一个默认的赋值运算符，执行浅拷贝（逐成员复制）。

xxxxxxxxxx
11
1
class Simple {
2
public:
3
    int value;
4
    string name;
5
    // 编译器生成的默认赋值运算符大致相当于：
6
    // Simple& operator=(const Simple& other) {
7
    //     value = other.value;
8
    //     name = other.name;
9
    //     return *this;
10
    // }
11
};

自定义赋值运算符

当类包含动态分配的资源时，需要自定义赋值运算符实现深拷贝。

xxxxxxxxxx
40
1
class DynamicArray {
2
private:
3
    int* data;
4
    int size;
5
    
6
public:
7
    // 构造函数
8
    DynamicArray(int sz) {
9
        size = sz;
10
        data = new int[size];
11
    }
12
    
13
    // 析构函数
14
    ~DynamicArray() {
15
        delete[] data;
16
    }
17
    
18
    // 赋值运算符（深拷贝）
19
    DynamicArray& operator=(const DynamicArray& other) {
20
        // 自我赋值检查
21
        if (this == &other) {
22
            return *this;
23
        }
24
        
25
        // 释放原有资源
26
        delete[] data;
27
        
28
        // 分配新资源
29
        size = other.size;
30
        data = new int[size];
31
        
32
        // 复制数据
33
        for (int i = 0; i < size; i++) {
34
            data[i] = other.data[i];
35
        }
36
        
37
        // 返回当前对象的引用
38
        return *this;
39
    }
40
};

赋值运算符的关键要点

自我赋值检查

防止对象赋值给自己时出现问题：

xxxxxxxxxx
3
1
if (this == &other) {
2
    return *this;
3
}

异常安全

确保在分配新资源失败时不会丢失原有资源：

xxxxxxxxxx
15
1
// 异常安全的赋值运算符
2
DynamicArray& operator=(const DynamicArray& other) {
3
    if (this != &other) {
4
        int* newData = new int[other.size];  // 先分配新内存
5
        
6
        delete[] data;  // 释放旧内存
7
        data = newData;  // 更新指针
8
        size = other.size;
9
        
10
        for (int i = 0; i < size; i++) {
11
            data[i] = other.data[i];
12
        }
13
    }
14
    return *this;
15
}

返回*this

返回对象自身的引用，支持连续赋值：

xxxxxxxxxx
1
1
a = b = c;  // 等价于 a = (b = c);

赋值运算符与拷贝构造函数的区别

• 赋值运算符：用于已存在对象之间的赋值

  xxxxxxxxxx
  2
  1
  MyClass a, b;
  2
  a = b;  // 调用赋值运算符
  

• 拷贝构造函数：用于创建新对象时的初始化

  xxxxxxxxxx
  2
  1
  MyClass a;
  2
  MyClass b = a;  // 调用拷贝构造函数
  

禁用赋值运算符

在某些情况下，可能需要禁止对象的赋值：

xxxxxxxxxx
12
1
class Uncopyable {
2
public:
3
    Uncopyable() {}
4
    
5
    // C++98/03方式：声明为私有但不定义
6
private:
7
    Uncopyable& operator=(const Uncopyable&);
8
    
9
    // C++11方式：使用delete关键字
10
public:
11
    Uncopyable& operator=(const Uncopyable&) = delete;
12
};

特殊数据成员

C++类中有几种特殊的数据成员，它们具有特殊的性质和用途。

静态数据成员（Static Data Members）

静态数据成员是属于类而非对象的成员变量，所有对象共享同一个静态数据成员。

xxxxxxxxxx
11
1
class Counter {
2
private:
3
    static int count;  // 静态数据成员声明
4
    
5
public:
6
    Counter() { count++; }
7
    static int getCount() { return count; }
8
};
9

10
// 必须在类外定义和初始化静态数据成员
11
int Counter::count = 0;

特点：

• 在类的所有对象间共享

• 必须在类外定义和初始化

• 可以通过类名直接访问：Counter::getCount()

• 存在于程序的整个生命周期

常量数据成员（Const Data Members）

常量数据成员是在对象创建后不能修改的成员变量。

xxxxxxxxxx
13
1
class Circle {
2
private:
3
    const double PI;  // 常量数据成员
4
    double radius;
5
    
6
public:
7
    // 常量成员必须在初始化列表中初始化
8
    Circle(double r) : PI(3.14159), radius(r) {}
9
    
10
    double getArea() const {
11
        return PI * radius * radius;
12
    }
13
};

特点：

• 必须在构造函数的初始化列表中初始化

• 初始化后不能修改

• 每个对象可以有不同的常量值

引用数据成员（Reference Data Members）

引用数据成员是对其他对象的引用。

xxxxxxxxxx
11
1
class Wrapper {
2
private:
3
    int& ref;  // 引用数据成员
4
    
5
public:
6
    // 引用成员必须在初始化列表中初始化
7
    Wrapper(int& r) : ref(r) {}
8
    
9
    void increment() { ref++; }
10
    int getValue() const { return ref; }
11
};

特点：

• 必须在构造函数的初始化列表中初始化

• 初始化后不能重新绑定到其他对象

• 对引用成员的修改会影响被引用的对象

特殊的成员函数

静态成员函数（Static Member Functions）

静态成员函数是属于类而非对象的函数，它们可以在不创建类的实例的情况下被调用。

特点

1. 不依赖对象实例：静态成员函数不与任何对象关联，可以通过类名直接调用

2. 没有this指针：由于不依赖对象实例，静态成员函数没有this指针

3. 只能访问静态成员：静态成员函数只能访问类的静态成员（静态数据成员和其他静态成员函数）

4. 不能声明为const：静态成员函数不能被声明为const、volatile或virtual

5. 不能使用非静态数据成员：不能直接访问类的非静态数据成员

语法

xxxxxxxxxx
31
1
class MyClass {
2
private:
3
    static int count;  // 静态数据成员
4
    int value;         // 非静态数据成员
5
    
6
public:
7
    // 静态成员函数
8
    static int getCount() {
9
        return count;  // 可以访问静态数据成员
10
        // return value;  // 错误！不能访问非静态数据成员
11
    }
12
    
13
    // 普通成员函数
14
    void increment() {
15
        value++;
16
        count++;  // 普通成员函数可以访问静态数据成员
17
    }
18
};
19

20
// 静态数据成员必须在类外定义
21
int MyClass::count = 0;
22

23
// 调用静态成员函数
24
int main() {
25
    int c1 = MyClass::getCount();  // 通过类名调用
26
    
27
    MyClass obj;
28
    int c2 = obj.getCount();  // 也可以通过对象调用（不推荐）
29
    
30
    return 0;
31
}

应用场景

1. 计数器：记录类创建了多少个实例

2. 工厂方法：创建类的实例

3. 单例模式：确保类只有一个实例

4. 工具函数：提供与类相关但不需要对象状态的功能

const成员函数（Const Member Functions）

const成员函数是承诺不会修改对象状态的成员函数，通过在函数声明后加const关键字实现。

特点

1. 不能修改对象状态：const成员函数不能修改非mutable的数据成员

2. 可以用于const对象：const对象只能调用const成员函数

3. this指针为const：在const成员函数中，this指针是指向const对象的指针

4. 可以重载：可以基于const限定符重载成员函数

5. 可以修改mutable成员：即使在const成员函数中，也可以修改声明为mutable的成员

语法

xxxxxxxxxx
45
1
class Rectangle {
2
private:
3
    double width;
4
    double height;
5
    mutable int accessCount;  // 可变成员
6
    
7
public:
8
    Rectangle(double w, double h) : width(w), height(h), accessCount(0) {}
9
    
10
    // const成员函数
11
    double getArea() const {
12
        accessCount++;  // 可以修改mutable成员
13
        return width * height;
14
        // width = 10;  // 错误！不能修改非mutable成员
15
    }
16
    
17
    // 非const成员函数
18
    void resize(double w, double h) {
19
        width = w;
20
        height = h;
21
    }
22
    
23
    // 基于const重载
24
    void print() const {
25
        std::cout << "Const版本: " << width << " x " << height << std::endl;
26
    }
27
    
28
    void print() {
29
        std::cout << "非Const版本: " << width << " x " << height << std::endl;
30
    }
31
};
32

33
int main() {
34
    Rectangle r(5, 3);
35
    r.getArea();  // 可以调用const成员函数
36
    r.resize(10, 6);  // 可以调用非const成员函数
37
    r.print();  // 调用非const版本
38
    
39
    const Rectangle cr(2, 4);
40
    cr.getArea();  // 可以调用const成员函数
41
    // cr.resize(3, 5);  // 错误！const对象不能调用非const成员函数
42
    cr.print();  // 调用const版本
43
    
44
    return 0;
45
}

应用场景

1. 访问器函数：获取对象状态但不修改它

2. 查询操作：执行不改变对象状态的操作

3. const对象的方法：允许const对象调用的方法

4. 线程安全：在多线程环境中表明函数不会修改共享数据

两者的比较

单例模式

单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。

单例模式的核心思想是：

• 确保类只有一个实例

• 提供全局访问该实例的方法

• 控制实例的创建时机

单例模式的实现方式

懒汉式（延迟初始化）

xxxxxxxxxx
29
1
class Singleton {
2
private:
3
    // 私有构造函数，防止外部创建实例
4
    Singleton() {}
5
    
6
    // 禁用拷贝构造和赋值操作
7
    Singleton(const Singleton&) = delete;
8
    Singleton& operator=(const Singleton&) = delete;
9
    
10
    // 静态实例指针
11
    static Singleton* instance;
12
    
13
public:
14
    // 获取实例的静态方法
15
    static Singleton* getInstance() {
16
        if (instance == nullptr) {
17
            instance = new Singleton();
18
        }
19
        return instance;
20
    }
21
    
22
    // 业务方法
23
    void doSomething() {
24
        // 实际功能
25
    }
26
};
27

28
// 静态成员初始化
29
Singleton* Singleton::instance = nullptr;

特点：

• 第一次调用getInstance()时才创建实例

• 存在线程安全问题

• 需要手动管理内存（可能导致内存泄漏）

饿汉式（立即初始化）

xxxxxxxxxx
26
1
class Singleton {
2
private:
3
    // 私有构造函数
4
    Singleton() {}
5
    
6
    // 禁用拷贝构造和赋值操作
7
    Singleton(const Singleton&) = delete;
8
    Singleton& operator=(const Singleton&) = delete;
9
    
10
    // 静态实例（程序启动时创建）
11
    static Singleton instance;
12
    
13
public:
14
    // 获取实例的静态方法
15
    static Singleton& getInstance() {
16
        return instance;
17
    }
18
    
19
    // 业务方法
20
    void doSomething() {
21
        // 实际功能
22
    }
23
};
24

25
// 静态成员初始化
26
Singleton Singleton::instance;

特点：

• 程序启动时就创建实例

• 线程安全

• 不需要考虑内存释放问题

• 可能造成资源浪费（如果该实例从未被使用）

线程安全的懒汉式（双检锁）

xxxxxxxxxx
36
1
#include <mutex>
2

3
class Singleton {
4
private:
5
    // 私有构造函数
6
    Singleton() {}
7
    
8
    // 禁用拷贝构造和赋值操作
9
    Singleton(const Singleton&) = delete;
10
    Singleton& operator=(const Singleton&) = delete;
11
    
12
    // 静态实例指针
13
    static Singleton* instance;
14
    static std::mutex mutex;
15
    
16
public:
17
    // 获取实例的静态方法（双检锁）
18
    static Singleton* getInstance() {
19
        if (instance == nullptr) {  // 第一次检查
20
            std::lock_guard<std::mutex> lock(mutex);
21
            if (instance == nullptr) {  // 第二次检查
22
                instance = new Singleton();
23
            }
24
        }
25
        return instance;
26
    }
27
    
28
    // 业务方法
29
    void doSomething() {
30
        // 实际功能
31
    }
32
};
33

34
// 静态成员初始化
35
Singleton* Singleton::instance = nullptr;
36
std::mutex Singleton::mutex;

特点：

• 线程安全

• 延迟初始化

• 双检锁提高性能

• 仍然存在内存泄漏问题

Meyers单例（C++11推荐）

xxxxxxxxxx
22
1
class Singleton {
2
private:
3
    // 私有构造函数
4
    Singleton() {}
5
    
6
    // 禁用拷贝构造和赋值操作
7
    Singleton(const Singleton&) = delete;
8
    Singleton& operator=(const Singleton&) = delete;
9
    
10
public:
11
    // 获取实例的静态方法
12
    static Singleton& getInstance() {
13
        // 局部静态变量
14
        static Singleton instance;
15
        return instance;
16
    }
17
    
18
    // 业务方法
19
    void doSomething() {
20
        // 实际功能
21
    }
22
};

特点：

• C++11保证了局部静态变量的线程安全初始化

• 简洁易用

• 自动管理内存（不会内存泄漏）

• 延迟初始化

单例模式的销毁

使用智能指针

xxxxxxxxxx
18
1
#include <memory>
2

3
class Singleton {
4
private:
5
    Singleton() {}
6
    
7
    static std::unique_ptr<Singleton> instance;
8
    
9
public:
10
    static Singleton& getInstance() {
11
        if (!instance) {
12
            instance.reset(new Singleton());
13
        }
14
        return *instance;
15
    }
16
};
17

18
std::unique_ptr<Singleton> Singleton::instance = nullptr;

使用嵌套类作为析构器

xxxxxxxxxx
31
1
class Singleton {
2
private:
3
    Singleton() {}
4
    
5
    static Singleton* instance;
6
    
7
    // 嵌套类作为析构器
8
    class Destructor {
9
    public:
10
        ~Destructor() {
11
            if (Singleton::instance) {
12
                delete Singleton::instance;
13
                Singleton::instance = nullptr;
14
            }
15
        }
16
    };
17
    
18
    // 静态析构器对象
19
    static Destructor destructor;
20
    
21
public:
22
    static Singleton* getInstance() {
23
        if (instance == nullptr) {
24
            instance = new Singleton();
25
        }
26
        return instance;
27
    }
28
};
29

30
Singleton* Singleton::instance = nullptr;
31
Singleton::Destructor Singleton::destructor;

单例模式的优缺点

优点：

• 保证一个类只有一个实例

• 提供全局访问点

• 实例在第一次使用时才被创建（懒汉式）

• 避免频繁创建和销毁实例

缺点：

• 单例模式违反了单一职责原则

• 隐藏了类之间的依赖关系

• 不利于单元测试

• 多线程环境下需要特别注意线程安全

std::string

C++风格字符串是指C++标准库中的std::string类，它是对C风格字符串的封装和扩展，提供了更安全、更方便的字符串处理方式。

std::string是C++标准库中的字符串类，定义在<string>头文件中，属于std命名空间。

xxxxxxxxxx
8
1
#include <string>
2
#include <iostream>
3

4
int main() {
5
    std::string str = "Hello, C++";
6
    std::cout << str << std::endl;
7
    return 0;
8
}

创建和初始化

xxxxxxxxxx
16
1
// 默认构造函数（空字符串）
2
std::string s1;
3

4
// 使用C风格字符串初始化
5
std::string s2 = "Hello";
6
std::string s3("World");
7

8
// 使用另一个string初始化
9
std::string s4 = s2;
10
std::string s5(s3);
11

12
// 使用部分字符串初始化
13
std::string s6(s2, 1, 3);  // 从s2的索引1开始，长度为3："ell"
14

15
// 重复字符初始化
16
std::string s7(5, 'A');  // "AAAAA"

基本操作

字符串连接

xxxxxxxxxx
8
1
std::string first = "Hello";
2
std::string last = "World";
3

4
// 使用+运算符
5
std::string message = first + " " + last;  // "Hello World"
6

7
// 使用append方法
8
first.append(" ").append(last);  // first变为"Hello World"

访问字符

xxxxxxxxxx
11
1
std::string str = "Hello";
2

3
// 使用[]运算符（不进行边界检查）
4
char c1 = str[0];  // 'H'
5

6
// 使用at方法（进行边界检查，越界抛出异常）
7
char c2 = str.at(1);  // 'e'
8

9
// 获取第一个和最后一个字符
10
char first = str.front();  // 'H'
11
char last = str.back();    // 'o'

字符串长度和容量

xxxxxxxxxx
13
1
std::string str = "Hello, World";
2

3
// 获取长度
4
size_t length = str.length();  // 12
5
size_t size = str.size();      // 12（与length相同）
6

7
// 检查是否为空
8
bool isEmpty = str.empty();  // false
9

10
// 容量管理
11
size_t capacity = str.capacity();  // 返回当前分配的存储空间大小
12
str.reserve(100);  // 预分配空间
13
str.shrink_to_fit();  // 减少容量以适应实际大小

子字符串

xxxxxxxxxx
4
1
std::string str = "Hello, World";
2

3
// 提取子字符串
4
std::string sub = str.substr(7, 5);  // "World"（从索引7开始，长度为5）

查找和替换

xxxxxxxxxx
13
1
std::string str = "Hello, World";
2

3
// 查找
4
size_t pos1 = str.find("World");  // 返回7
5
size_t pos2 = str.find('o');      // 返回4（第一个'o'的位置）
6
size_t pos3 = str.rfind('o');     // 返回8（最后一个'o'的位置）
7

8
// 查找任意字符
9
size_t pos4 = str.find_first_of("aeiou");  // 返回1（第一个元音字母'e'的位置）
10
size_t pos5 = str.find_last_of("aeiou");   // 返回8（最后一个元音字母'o'的位置）
11

12
// 替换
13
str.replace(7, 5, "C++");  // "Hello, C++"（从索引7开始，替换5个字符）

插入和删除

xxxxxxxxxx
7
1
std::string str = "Hello";
2

3
// 插入
4
str.insert(5, " World");  // "Hello World"
5

6
// 删除
7
str.erase(5, 6);  // "Hello"（从索引5开始删除6个字符）

比较

xxxxxxxxxx
9
1
std::string s1 = "apple";
2
std::string s2 = "banana";
3

4
// 使用比较运算符
5
bool less = s1 < s2;       // true
6
bool equal = s1 == "apple"; // true
7

8
// 使用compare方法
9
int result = s1.compare(s2);  // 负值，表示s1小于s2

与C风格字符串的转换

C++字符串转C风格字符串

xxxxxxxxxx
7
1
std::string cppStr = "Hello";
2

3
// 获取C风格字符串（只读）
4
const char* cStr = cppStr.c_str();
5

6
// 获取字符数组（只读）
7
const char* data = cppStr.data();

C风格字符串转C++字符串

xxxxxxxxxx
2
1
const char* cStr = "Hello";
2
std::string cppStr(cStr);

字符串流

xxxxxxxxxx
12
1
#include <sstream>
2

3
// 字符串构建
4
std::ostringstream oss;
5
oss << "Name: " << "John" << ", Age: " << 30;
6
std::string result = oss.str();  // "Name: John, Age: 30"
7

8
// 字符串解析
9
std::string input = "123 456";
10
std::istringstream iss(input);
11
int a, b;
12
iss >> a >> b;  // a=123, b=456

字符串转换

xxxxxxxxxx
8
1
// 字符串转数字
2
std::string numStr = "123";
3
int num = std::stoi(numStr);       // 字符串转int
4
double dbl = std::stod("3.14159"); // 字符串转double
5

6
// 数字转字符串
7
std::string s1 = std::to_string(123);    // 整数转字符串
8
std::string s2 = std::to_string(3.14159); // 浮点数转字符串