类与对象

• 类的定义与对象的创建
  类是对象的蓝图，它定义了对象的属性（成员变量）和行为（成员函数）。通过类创建的实体就是对象。

  class Car {
  public:
      int speed;
      void drive() { std::cout << "Driving at " << speed << " km/h" << std::endl; }
  };

  Car myCar;  // 创建对象
  myCar.speed = 100;  // 设置对象属性
  myCar.drive();  // 调用对象方法

• 构造函数与析构函数
  构造函数在对象创建时自动调用，用于初始化对象的状态；析构函数在对象销毁时调用，用于释放资源。

  class MyClass {
  public:
      MyClass() { std::cout << "Constructor called" << std::endl; }
      ~MyClass() { std::cout << "Destructor called" << std::endl; }
  };
  MyClass obj;  // 创建对象，构造函数被调用

成员函数与成员变量

• 成员函数
  成员函数是类的行为定义，通过对象调用执行：

  class Box {
  public:
      int length;
      void setLength(int len) { length = len; }
      int getLength() { return length; }
  };
  Box box;
  box.setLength(5);
  std::cout << "Length: " << box.getLength() << std::endl;

• 成员变量
  成员变量是类的属性，用于存储对象的状态：

  class Circle {
  public:
      double radius;
  };
  Circle circle;
  circle.radius = 7.5;

访问控制（public、private、protected）

• public：成员对所有类和外部代码可见。
• private：成员仅对类的成员函数和友元可见。
• protected：成员对类及派生类可见，但外部不可访问。 示例：

  class Employee {
  private:
      int salary;
  public:
      void setSalary(int s) { salary = s; }
      int getSalary() { return salary; }
  };

this指针

• this指针是类的成员函数隐式传递的指针，指向当前对象的地址。

  class Person {
  public:
      void setAge(int age) {
          this->age = age;  // 使用this指针访问成员变量
      }
  private:
      int age;
  };

继承

• 基类与派生类
  继承允许一个类从另一个类继承属性和行为。基类是被继承的类，派生类是继承类。

  class Animal {
  public:
      void eat() { std::cout << "Eating..." << std::endl; }
  };
  class Dog : public Animal {  // Dog继承Animal
  public:
      void bark() { std::cout << "Barking!" << std::endl; }
  };

• 继承的类型
• 公有继承（public）：基类的public成员变为派生类的public成员。
• 私有继承（private）：基类的public和protected成员变为派生类的private成员。
• 保护继承（protected）：基类的public和protected成员变为派生类的protected成员。 示例：

  class Animal {
  public:
      void sound() { std::cout << "Some sound" << std::endl; }
  };
  class Dog : protected Animal {  // 保护继承
  public:
      void bark() { sound(); }
  };

• 构造函数与析构函数的继承
  派生类可以继承基类的构造函数，但基类的析构函数不被继承。派生类必须自己定义析构函数来释放资源。

虚函数与多态（动态绑定）

• 虚函数
  虚函数用于实现多态，它在基类中声明并且通过指针或引用调用时会动态绑定到派生类的函数。

  class Shape {
  public:
      virtual void draw() { std::cout << "Drawing Shape" << std::endl; }
  };
  class Circle : public Shape {
  public:
      void draw() override { std::cout << "Drawing Circle" << std::endl; }
  };

• 多态的实现：基类指针指向派生类对象
  通过基类指针调用虚函数时，C++会根据实际对象的类型动态决定调用哪一个函数（运行时多态）。

  Shape* shape = new Circle();
  shape->draw();  // 调用Circle类的draw函数

多态

• 函数重载与运算符重载
  函数重载允许多个同名函数，但其参数类型或数量不同。运算符重载允许自定义运算符的行为。

  class Complex {
  public:
      int real, imag;
      Complex operator+(const Complex& other) {
          Complex temp;
          temp.real = this->real + other.real;
          temp.imag = this->imag + other.imag;
          return temp;
      }
  };

• 虚函数与纯虚函数
• 虚函数：基类中声明的虚函数允许派生类重写。
• 纯虚函数：基类中的虚函数，没有实现，强制派生类实现该函数。

  class Shape {
  public:
      virtual void draw() = 0;  // 纯虚函数
  };

• 抽象类
  包含纯虚函数的类称为抽象类，不能实例化。

  class Shape {
  public:
      virtual void draw() = 0;
  };

封装与抽象

• 数据隐藏
  封装通过将数据和方法组织在类中，并将数据的访问限制为私有（private），从而实现数据隐藏。

  class BankAccount {
  private:
      double balance;
  public:
      void deposit(double amount) { balance += amount; }
      double getBalance() { return balance; }
  };

• 接口与抽象类
  抽象类是一种特殊的接口，它只包含纯虚函数，不能直接创建对象。

  class Drawable {
  public:
      virtual void draw() = 0;  // 抽象类
  };

友元函数与友元类

• 友元函数
  友元函数可以访问类的私有成员，即使它不是类的成员函数。

  class Box {
  private:
      int length;
  public:
      friend void printLength(Box b);  // 声明友元函数
  };
  void printLength(Box b) {
      std::cout << "Length: " << b.length << std::endl;
  }

• 友元类
  友元类可以访问另一个类的私有和保护成员。

  class Box {
  private:
      int length;
  public:
      friend class Printer;  // 声明友元类
  };

总结

面向对象编程（OOP）是C++的重要特性之一，通过类与对象、继承、多态、封装等机制，帮助程序员组织代码、提高复用性、扩展性与维护性。掌握OOP的概念和实践是编写高质量C++代码的关键。