类基础用法

1. 类与对象简介#

1.1 什么是类和对象#

**类（Class）**是C++中创建用户自定义类型的一种方式，它将数据（成员变量）和操作数据的函数（成员函数）封装在一起。
**对象（Object）**是类的实例化，拥有类定义的所有属性和行为。
类更像是汽车图纸，对象更像是造出来的汽车。

1.2 类的作用#

封装（Encapsulation）：将数据和操作数据的代码绑定在一起，保护数据不被外界直接访问。
抽象（Abstraction）：通过类定义抽象出具有共同特性的对象，提高代码的可重用性和可维护性。
继承（Inheritance）和多态（Polymorphism）：实现代码的复用与动态绑定。

2. 类的定义#

2.1 基本语法#

1
class ClassName {
2
public:
3
    // 公有成员
4
private:
5
    // 私有成员
6
protected:
7
    // 受保护成员
8
};

2.2 示例#

创建一个表示学生的类：

1
#include <string>
2

3
class Student {
4
public:
5
    // 公有构造函数
6
    Student(const std::string& name, int age);
7

8
    // 公有成员函数
9
    void setName(const std::string& name);
10
    std::string getName() const;
11

12
    void setAge(int age);
13
    int getAge() const;
14

15
private:
16
    // 私有成员变量
17
    std::string name_;
18
    int age_;
19
};

3. 成员变量与成员函数#

3.1 成员变量#

成员变量（Member Variables）：用于存储对象的状态信息。
命名约定：常用下划线结尾（例如 name_）表示成员变量，避免与局部变量混淆。

3.2 成员函数#

成员函数（Member Functions）：定义对象的行为，可以访问和修改成员变量。
常成员函数（Const Member Functions）：保证函数不会修改对象的状态。

3.3 示例实现#

1
#include "Student.h"
2

3
Student::Student(const std::string& name, int age)
4
    : name_(name), age_(age) {}
5

6
void Student::setName(const std::string& name) {
7
    name_ = name;
8
}
9

10
std::string Student::getName() const {
11
    return name_;
12
}
13

14
void Student::setAge(int age) {
15
    if (age > 0)
16
        age_ = age;
17
}
18

19
int Student::getAge() const {
20
    return age_;
21
}

4. 访问控制#

4.1 访问修饰符#

public：公有成员，可以被所有代码访问。
private：私有成员，仅能被类的成员函数和友元访问。
protected：受保护成员，仅能被类的成员函数、友元和派生类访问。

4.2 例子#

1
class Sample {
2
public:
3
    void publicFunction();
4

5
private:
6
    int privateVar_;
7
    void privateFunction();
8

9
protected:
10
    int protectedVar_;
11
};

5. 构造函数与析构函数#

5.1 构造函数#

默认构造函数：没有参数的构造函数。
参数化构造函数：接受参数以初始化对象。
拷贝构造函数：用一个对象初始化另一个对象。
移动构造函数（C++11）：从临时对象“移动”资源。

5.2 析构函数#

析构函数（Destructor）：在对象生命周期结束时调用，用于释放资源。

5.3 示例#

1
#include <iostream>
2

3
class Example {
4
public:
5
    // 默认构造函数
6
    Example() : data_(0) {
7
        std::cout << "Default constructor called.\n";
8
    }
9

10
    // 参数化构造函数
11
    Example(int data) : data_(data) {
12
        std::cout << "Parameterized constructor called with data = " << data_ << ".\n";
13
    }
14

15
    // 拷贝构造函数
16
    Example(const Example& other) : data_(other.data_) {
17
        std::cout << "Copy constructor called.\n";
18
    }
19

20
    // 移动构造函数
21
    Example(Example&& other) noexcept : data_(other.data_) {
22
        other.data_ = 0;
23
        std::cout << "Move constructor called.\n";
24
    }
25

26
    // 析构函数
27
    ~Example() {
28
        std::cout << "Destructor called for data = " << data_ << ".\n";
29
    }
30

31
private:
32
    int data_;
33
};

5.4 使用示例#

1
int main() {
2
    Example ex1;               // 调用默认构造函数
3
    Example ex2(42);           // 调用参数化构造函数
4
    Example ex3 = ex2;         // 调用拷贝构造函数
5
    Example ex4 = std::move(ex2); // 调用移动构造函数
6
    return 0;
7
}

输出示例：

1
Default constructor called.
2
Parameterized constructor called with data = 42.
3
Copy constructor called.
4
Move constructor called.
5
Destructor called for data = 0.
6
Destructor called for data = 42.
7
Destructor called for data = 42.

6. 拷贝控制#

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

6.1 拷贝构造函数#

定义：用于创建一个新对象，并复制现有对象的成员。
语法：ClassName(const ClassName& other);

6.2 拷贝赋值运算符#

定义：用于将一个已有对象的值赋给另一个已有对象。
语法：ClassName& operator=(const ClassName& other);

6.3 示例#

1
#include <iostream>
2
#include <cstring>
3

4
class MyString {
5
public:
6
    // 构造函数
7
    MyString(const char* str = nullptr) {
8
        if (str) {
9
            size_ = std::strlen(str);
10
            data_ = new char[size_ + 1];
11
            std::strcpy(data_, str);
12
        } else {
13
            size_ = 0;
14
            data_ = new char[1];
15
            data_[0] = '\0';
16
        }
17
        std::cout << "Constructor called.\n";
18
    }
19

20
    // 拷贝构造函数
21
    MyString(const MyString& other) : size_(other.size_) {
22
        data_ = new char[size_ + 1];
23
        std::strcpy(data_, other.data_);
24
        std::cout << "Copy constructor called.\n";
25
    }
26

27
    // 拷贝赋值运算符
28
    MyString& operator=(const MyString& other) {
29
        std::cout << "Copy assignment operator called.\n";
30
        if (this == &other)
31
            return *this; // 自赋值检查
32

33
        delete[] data_; // 释放现有资源
34

35
        size_ = other.size_;
36
        data_ = new char[size_ + 1];
37
        std::strcpy(data_, other.data_);
38
        return *this;
39
    }
40

41
    // 析构函数
42
    ~MyString() {
43
        delete[] data_;
44
        std::cout << "Destructor called.\n";
45
    }
46

47
    void print() const {
48
        std::cout << data_ << "\n";
49
    }
50

51
private:
52
    char* data_;
53
    std::size_t size_;
54
};

6.4 使用示例#

1
int main() {
2
    MyString s1("Hello");
3
    MyString s2 = s1;        // 调用拷贝构造函数
4
    MyString s3;
5
    s3 = s1;                  // 调用拷贝赋值运算符
6

7
    s1.print();
8
    s2.print();
9
    s3.print();
10
    return 0;
11
}

输出示例：

1
Constructor called.
2
Copy constructor called.
3
Constructor called.
4
Copy assignment operator called.
5
Hello
6
Hello
7
Hello
8
Destructor called.
9
Destructor called.
10
Destructor called.

7. 移动语义#

7.1 什么是移动语义#

移动语义（Move Semantics）：允许资源的所有权从一个对象转移到另一个对象，避免不必要的拷贝，提高性能。

7.2 移动构造函数与移动赋值运算符#

移动构造函数：ClassName(ClassName&& other) noexcept;
移动赋值运算符：ClassName& operator=(ClassName&& other) noexcept;

7.3 示例#

1
#include <iostream>
2
#include <utility>
3

4
class MoveExample {
5
public:
6
    // 构造函数
7
    MoveExample(int size) : size_(size), data_(new int[size]) {
8
        std::cout << "Constructor called.\n";
9
    }
10

11
    // 拷贝构造函数
12
    MoveExample(const MoveExample& other) : size_(other.size_), data_(new int[other.size_]) {
13
        std::copy(other.data_, other.data_ + size_, data_);
14
        std::cout << "Copy constructor called.\n";
15
    }
16

17
    // 移动构造函数
18
    MoveExample(MoveExample&& other) noexcept : size_(other.size_), data_(other.data_) {
19
        other.size_ = 0;
20
        other.data_ = nullptr;
21
        std::cout << "Move constructor called.\n";
22
    }
23

24
    // 拷贝赋值运算符
25
    MoveExample& operator=(const MoveExample& other) {
26
        std::cout << "Copy assignment operator called.\n";
27
        if (this == &other)
28
            return *this;
29

30
        delete[] data_;
31
        size_ = other.size_;
32
        data_ = new int[size_];
33
        std::copy(other.data_, other.data_ + size_, data_);
34
        return *this;
35
    }
36

37
    // 移动赋值运算符
38
    MoveExample& operator=(MoveExample&& other) noexcept {
39
        std::cout << "Move assignment operator called.\n";
40
        if (this == &other)
41
            return *this;
42

43
        delete[] data_;
44
        size_ = other.size_;
45
        data_ = other.data_;
46

47
        other.size_ = 0;
48
        other.data_ = nullptr;
49
        return *this;
50
    }
51

52
    // 析构函数
53
    ~MoveExample() {
54
        delete[] data_;
55
        std::cout << "Destructor called.\n";
56
    }
57

58
private:
59
    int size_;
60
    int* data_;
61
};

7.4 使用示例#

1
int main() {
2
    MoveExample ex1(100);                 // Constructor
3
    MoveExample ex2 = ex1;                // Copy Constructor
4
    MoveExample ex3 = MoveExample(200);   // Move Constructor
5

6
    MoveExample ex4(300);
7
    ex4 = ex1;                             // Copy Assignment
8
    ex4 = MoveExample(400);                // Move Assignment
9

10
    return 0;
11
}

输出示例：

1
Constructor called.
2
Copy constructor called.
3
Constructor called.
4
Move constructor called.
5
Destructor called.
6
Constructor called.
7
Copy assignment operator called.
8
Move constructor called.
9
Move assignment operator called.
10
Destructor called.
11
Destructor called.
12
Destructor called.
13
Destructor called.

8. 类的友元#

8.1 什么是友元#

友元（Friend）：可以访问类的私有和保护成员的非成员函数或另一个类。

8.2 类型#

友元函数：单个函数可以被声明为友元。
友元类：整个类可以被声明为友元。

8.3 使用示例#

1
#include <iostream>
2

3
class Box {
4
public:
5
    Box(double length, double width, double height)
6
        : length_(length), width_(width), height_(height) {}
7

8
    // 声明友元函数
9
    friend double calculateVolume(const Box& b);
10

11
private:
12
    double length_;
13
    double width_;
14
    double height_;
15
};
16

17
// 友元函数定义
18
double calculateVolume(const Box& b) {
19
    return b.length_ * b.width_ * b.height_;
20
}

8.4 使用友元类#

1
class Rectangle {
2
public:
3
    Rectangle(double width, double height) : width_(width), height_(height) {}
4

5
private:
6
    double width_;
7
    double height_;
8

9
    // 声明友元类
10
    friend class AreaCalculator;
11
};
12

13
class AreaCalculator {
14
public:
15
    double calculateArea(const Rectangle& rect) {
16
        return rect.width_ * rect.height_;
17
    }
18
};

9. 运算符重载#

9.1 什么是运算符重载#

运算符重载（Operator Overloading）：允许对自定义类型使用C++运算符，如 +, -, << 等。

9.2 重载运算符的规则#

只能对已有运算符进行重载，不能创建新运算符。
至少有一个操作数必须是用户定义的类型。
不能改变运算符的优先级或结合性。

9.3 示例：重载 `+` 运算符#

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

4
class Point {
5
public:
6
    Point(double x, double y) : x_(x), y_(y) {}
7

8
    // 成员函数重载 +
9
    Point operator+(const Point& other) const {
10
        return Point(x_ + other.x_, y_ + other.y_);
11
    }
12

13
    void print() const {
14
        std::cout << "(" << x_ << ", " << y_ << ")\n";
15
    }
16

17
private:
18
    double x_;
19
    double y_;
20
};
21

22
// 也可以使用友元函数重载 +
23

24
Point operator-(const Point& a, const Point& b) {
25
    return Point(a.x_ - b.x_, a.y_ - b.y_);
26
}
27

28
int main() {
29
    Point p1(1.5, 2.5);
30
    Point p2(3.0, 4.0);
31

32
    Point p3 = p1 + p2;
33
    p3.print(); // 输出： (4.5, 6.5)
34

35
    Point p4 = p2 - p1;
36
    p4.print(); // 输出： (1.5, 1.5)
37

38
    return 0;
39
}

9.4 示例：重载 `<<` 运算符（输出流）#

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

4
class Employee {
5
public:
6
    Employee(const std::string& name, double salary)
7
        : name_(name), salary_(salary) {}
8

9
    // 声明友元函数以重载 <<
10
    friend std::ostream& operator<<(std::ostream& os, const Employee& emp);
11

12
private:
13
    std::string name_;
14
    double salary_;
15
};
16

17
// 定义重载的 <<
18
std::ostream& operator<<(std::ostream& os, const Employee& emp) {
19
    os << "Employee Name: " << emp.name_ << ", Salary: $" << emp.salary_;
20
    return os;
21
}
22

23
int main() {
24
    Employee emp("John Doe", 75000);
25
    std::cout << emp << std::endl;
26
    return 0;
27
}

输出示例：

1
Employee Name: John Doe, Salary: $75000

1. 类与对象简介#

1.1 什么是类和对象#

1.2 类的作用#

2. 类的定义#

2.1 基本语法#

2.2 示例#

3. 成员变量与成员函数#

3.1 成员变量#

3.2 成员函数#

3.3 示例实现#

4. 访问控制#

4.1 访问修饰符#

4.2 例子#

5. 构造函数与析构函数#

5.1 构造函数#

5.2 析构函数#

5.3 示例#

5.4 使用示例#

6. 拷贝控制#

6.1 拷贝构造函数#

6.2 拷贝赋值运算符#

6.3 示例#

6.4 使用示例#

7. 移动语义#

7.1 什么是移动语义#

7.2 移动构造函数与移动赋值运算符#

7.3 示例#

7.4 使用示例#

8. 类的友元#

8.1 什么是友元#

8.2 类型#

8.3 使用示例#

8.4 使用友元类#

9. 运算符重载#

9.1 什么是运算符重载#

9.2 重载运算符的规则#

9.3 示例：重载 `+` 运算符#

9.4 示例：重载 `<<` 运算符（输出流）#

文章分享

评论区

1. 类与对象简介#

1.1 什么是类和对象#

1.2 类的作用#

2. 类的定义#

2.1 基本语法#

2.2 示例#

3. 成员变量与成员函数#

3.1 成员变量#

3.2 成员函数#

3.3 示例实现#

4. 访问控制#

4.1 访问修饰符#

4.2 例子#

5. 构造函数与析构函数#

5.1 构造函数#

5.2 析构函数#

5.3 示例#

5.4 使用示例#

6. 拷贝控制#

6.1 拷贝构造函数#

6.2 拷贝赋值运算符#

6.3 示例#

6.4 使用示例#

7. 移动语义#

7.1 什么是移动语义#

7.2 移动构造函数与移动赋值运算符#

7.3 示例#

7.4 使用示例#

8. 类的友元#

8.1 什么是友元#

8.2 类型#

8.3 使用示例#

8.4 使用友元类#

9. 运算符重载#

9.1 什么是运算符重载#

9.2 重载运算符的规则#

9.3 示例：重载 + 运算符#

9.4 示例：重载 << 运算符（输出流）#

文章分享

评论区

9.3 示例：重载 `+` 运算符#

9.4 示例：重载 `<<` 运算符（输出流）#