第二弹：面向对象编程中的类与对象

文章目录

面向对象编程中的类与对象
- 1. 类与对象的定义
- - 1.1 类和对象的概念
  - 1.2 类的基本定义
- 2. 类的封装
- - 2.1 类的封装语法
  - 2.2 类成员访问权限
  - 2.3 `struct`和`class`的区别
  - 2.4 类封装与成员函数定义分离
- 3. 类对象的创建与销毁
- - 3.1 静态与动态对象的创建
  - 3.2 对象的销毁
- 4. 构造函数和析构函数
- - 4.1 构造函数
  - 4.2 析构函数
  - 4.3 拷贝构造函数
  - 4.4 移动构造函数
- 5. 类成员是类对象
- - 5.1 初始化列表
  - 5.2 组合类的构造与析构
- 6. 类的特殊成员
- - 6.1 类成员的存储
  - 6.2 this指针
  - 6.3 static成员
  - 6.4 const修饰类
  - 实践练习：复数类的实现
- 总结

面向对象编程中的类与对象

在现代编程中，面向对象（Object-Oriented Programming, OOP）已成为一种常用且强大的编程范式。OOP的核心思想包括封装、继承和多态，其中类和对象是基础概念。本文将深入探讨类与对象的定义、封装、创建与销毁、以及相关的特殊成员与功能。

1. 类与对象的定义

1.1 类和对象的概念

在OOP中，对象是现实世界中一个具体的实体，它具有属性和行为。我们可以通过编程语言将现实世界中的对象抽象为计算机中的类。类定义了对象的属性和行为，而对象则是类的一个实例化。

对象：对象是一个具体存在的实体，具有属性（如颜色、大小等）和行为（如运动、停止等）。
类：类是对对象的抽象，通过封装对象的属性和行为，使得我们可以在计算机中实现这些对象。

1.2 类的基本定义

类是对一类对象的抽象描述，它包含成员变量（对象的属性）和成员函数（对象的行为）。在C++中，类的定义可以使用class或struct关键字进行。

class 类名称 {
  // 类对象的属性和行为成员的存储列表
};

其中，class是用于封装类的关键字，它封装了类的属性（成员变量）和行为（成员函数）。类中的属性可以是私有的或公开的，而行为则可以根据需要设置访问权限。

2. 类的封装

封装是OOP的三大特性之一，指的是将数据和操作封装在类内部，控制外部对类成员的访问，以保证数据的安全性和完整性。

2.1 类的封装语法

类的封装语法非常简单，类的属性和行为通过成员变量和成员函数体现。

class 类名称 {
  // 成员变量与成员函数
};

2.2 类成员访问权限

C++提供了三种访问权限修饰符：

private：只能在类内部访问，外部不能直接访问。
protected：可以在当前类和派生类中访问。
public：可以在任何位置访问，包括类外部。
-

使用这些访问控制修饰符，可以控制哪些属性或行为对外界是可见的。

2.3 `struct`和`class`的区别

在C++中，struct和class本质上都是用于定义类的关键字，但它们的默认访问权限不同：
- struct的成员默认是public权限。
- class的成员默认是private权限。

因此，在大多数C++项目中，struct通常用于简单的数据结构，而class则用于复杂的对象封装。

2.4 类封装与成员函数定义分离

在C++中，类的成员函数可以在类外部定义。这不仅可以使代码结构更加清晰，还可以将类的声明与实现分离。

class 类名称 {
  void 函数名();
};

void 类名称::函数名() {
  // 函数体
}

这种定义与实现的分离可以在大型项目中提高代码的可维护性。

3. 类对象的创建与销毁

3.1 静态与动态对象的创建

C++中的对象可以通过两种方式创建：静态创建和动态创建。

静态创建：在栈上分配内存，生命周期由函数的作用域控制。
动态创建：在堆上分配内存，生命周期由程序员手动控制，必须在适当的时候释放内存。

class Demo {
  int val;
  void Print();
};

Demo obj; // 静态创建
Demo* p = new Demo(); // 动态创建
delete p; // 动态销毁

3.2 对象的销毁

当对象不再需要时，必须释放其占用的资源。对于静态对象，销毁时自动调用析构函数；对于动态对象，必须使用delete显式销毁。

4. 构造函数和析构函数

4.1 构造函数

构造函数是对象在创建时自动调用的特殊函数，用于初始化对象的成员变量。它可以有参数，也可以是无参的。构造函数是可重载的，即可以定义多个构造函数来实现不同的初始化方式。

class Demo {
  Demo(); // 无参构造函数
  Demo(int val); // 有参构造函数
};

4.2 析构函数

析构函数是对象销毁时自动调用的特殊函数，用于释放对象所占用的资源。它没有参数，也不能被重载。

class Demo {
  ~Demo();
};

4.3 拷贝构造函数

当使用一个对象来初始化另一个对象时，拷贝构造函数会被调用。默认的拷贝构造函数是浅拷贝，但可以自定义深拷贝来避免指针成员的内存管理问题。

class Demo {
  Demo(const Demo &obj); // 拷贝构造函数
};

4.4 移动构造函数

C++11引入了移动构造函数，以提高对象转移时的效率。移动构造函数通过转移资源而不是拷贝资源来避免不必要的性能开销。

class Demo {
  Demo(Demo &&obj); // 移动构造函数
};

5. 类成员是类对象

在某些场景中，类的成员变量可以是其他类的对象。这种关系被称为组合关系，用于表示“has-a”关系。

5.1 初始化列表

初始化列表是一种高效的初始化方式，常用于类的成员对象或const成员的初始化。

class Demo {
  Demo(int a, int b) : a(a), b(b) {}
};

5.2 组合类的构造与析构

在组合类的构造函数中，成员对象的构造函数首先被调用，随后是组合类的构造函数；在析构函数中，情况则相反。

class A {
  A(int x);
};
class B {
  B(int y);
};
class Demo {
  A a_obj;
  B b_obj;
  Demo(int x, int y) : a_obj(x), b_obj(y) {}
};

6. 类的特殊成员

6.1 类成员的存储

类的成员变量在对象创建时分配存储空间，而成员函数则在类的外部共享代码块，多个对象共享同一份成员函数的代码。

6.2 this指针

this指针是C++中特殊的指针，指向当前对象。通过this指针，类的成员函数可以访问调用该函数的对象。

class Demo {
  void setVal(int val) {
    this->val = val;
  }
};

6.3 static成员

static成员属于整个类，而非某个具体的对象。静态成员变量在类外部定义，而静态成员函数可以在不实例化对象的情况下访问。

class Stu {
  static int Class;
};

int Stu::Class;

静态成员函数只能访问静态成员，且不需要通过对象调用。

class Stu {
  static void Print();
};
Stu::Print();

6.4 const修饰类

const修饰的成员变量在初始化后不能被修改；
const修饰的成员函数不能修改对象的状态；
const修饰的类对象只能调用const成员函数。

class Demo {
  int getVal() const; // const成员函数
};
const Demo obj;
obj.getVal(); // const对象只能调用const函数

实践练习：复数类的实现

我们可以通过定义一个复数类来练习面向对象编程中的类和对象的概念。该类应支持复数的初始化、输出以及加减乘除运算。

class Complex {
  int real, imag;
public:
  Complex(int r, int i) : real(r), imag(i) {}
  void display() {
    cout << real << " + " << imag << "i" << endl;
  }
  Complex add(Complex c) {
    return Complex(real + c.real, imag + c.imag);
  }
};