类（Class）
类是C++中的一个用户定义的数据类型，它定义了一组属性（数据成员）和方法（成员函数），用于表示和操作一类实体的共有特征。类是描述对象的蓝图或模板。在C++中，类的定义是创建自定义数据类型的一种方式，它由一组成员变量（数据成员）和成员函数（方法）组成。下面将详细介绍类的定义，包括语法、访问控制、构造函数与析构函数、成员函数、友元函数等内容。
1. 类的基本语法
class ClassName {
public: // 访问控制 // 数据成员 DataType memberVariable; // 构造函数 ClassName(parameters); // 成员函数 ReturnType memberFunction(parameters); private: // 访问控制 // 私有数据成员或成员函数 protected: // 访问控制 // 保护数据成员或成员函数
};2. 访问控制
C++中的类提供了三种访问控制修饰符：
- public：公共成员，可以被任何其他代码访问。
- private：私有成员，仅可以在类内部访问，外部无法直接访问。
- protected：保护成员，可以在类内部和派生类中访问，但在外部无法直接访问。
- 示例：
class Example { public: int publicVar; // 公有成员 private: int privateVar; // 私有成员 protected: int protectedVar; // 保护成员 };
3. 数据成员
数据成员是类的属性，用于存储对象的状态。可以是基本数据类型、结构体、类的实例或其他复杂类型。
示例：
class Person {
public: std::string name; // 姓名 int age; // 年龄
};4. 构造函数与析构函数
-
构造函数：用于初始化对象的特殊成员函数，名称与类名相同, 可以重载。构造函数可以接受参数，也可以是默认构造函数（无参数构造函数）。
-
析构函数：用于清理对象并释放资源的特殊成员函数，名称与类名相同，但前面加上波浪符
~。析构函数无法重载，并且不能带参数。
示例：
class Car {
public: std::string brand; int year; // 构造函数 Car(std::string b, int y) : brand(b), year(y) { std::cout << "Car created: " << brand << " " << year << std::endl; } // 析构函数 ~Car() { std::cout << "Car destroyed: " << brand << " " << year << std::endl; }
};5. 成员函数
成员函数是类内定义的函数，用于对成员变量进行操作。成员函数可以修改类的私有成员，在类外部通过对象调用时可以访问公共成员。
示例：
class Rectangle {
private: double width, height; public: Rectangle(double w, double h) : width(w), height(h) {} double area() { return width * height; // 计算面积 }
};6. 友元函数
友元函数是可以访问类的私有和保护成员的函数，即使它不是该类的成员。可以将其声明为友元，以实现特定需要。
示例：
class Box {
private: double width; public: Box(double w) : width(w) {} friend void printWidth(Box b); // 声明友元函数
}; void printWidth(Box b) { std::cout << "Width: " << b.width << std::endl; // 访问私有成员
}7. 完整示例
将上述所有内容结合起来，我们可以定义一个完整的类：
#include <iostream>
#include <string> class Car {
private: std::string brand; int year; public: // 构造函数 Car(std::string b, int y) : brand(b), year(y) {} // 成员函数 void displayInfo() { std::cout << "Brand: " << brand << ", Year: " << year << std::endl; } // 友元函数 friend void showBrand(Car c);
}; // 友元函数实现
void showBrand(Car c) { std::cout << "Brand from friend function: " << c.brand << std::endl;
} int main() { Car myCar("Toyota", 2020); myCar.displayInfo(); showBrand(myCar); // 调用友元函数 return 0;
}8.基本特性
1.封装：
封装是将数据和操作数据的函数（方法）组合在一起，通过将数据的具体实现细节隐藏在类内部，保持类的内部状态独立于外部世界。封装使用访问控制修饰符（public、private、protected）来限定对类成员的访问。
优点：
- 数据保护：防止未经授权的访问和修改。
- 易于维护：内部实现可以修改而不影响外部代码。
示例：
class BankAccount {
private: double balance; // 私有数据成员 public: BankAccount(double initialBalance) : balance(initialBalance) {} void deposit(double amount) { if (amount > 0) { balance += amount; // 允许访问私有成员 } } double getBalance() const { return balance; // 可以读取余额，但不允许直接修改 }
};2.抽象：
继承是一个类（子类）基于另一个类（父类）创建新类的机制，使得子类可以继承父类的属性和方法。通过继承，子类可以重用代码，扩展功能，以及更好地组织相关的实体。
优点：
- 代码重用：子类可以使用父类的成员。
- 形成类之间的层次结构，增强可扩展性。
示例：
class Animal {
public: void eat() { std::cout << "Eating..." << std::endl; }
}; class Dog : public Animal {
public: void bark() { std::cout << "Woof!" << std::endl; }
}; int main() { Dog dog; dog.eat(); // 继承的功能 dog.bark(); // 子类特有的功能 return 0;
}3.继承：
多态是指同一操作可以作用于不同类型的对象，表现出不同的行为。C++ 通过虚函数和函数重载实现多态性。多态可以分为编译时多态（函数重载和运算符重载）和运行时多态（通过虚函数实现）。
优点：
- 灵活性：同一接口可以产生不同的行为。
- 可扩展性：可以在不更改现有代码的情况下添加新功能。
示例：
class Base {
public: virtual void show() { // 虚函数 std::cout << "Base class show function." << std::endl; }
}; class Derived : public Base {
public: void show() override { // 重写虚函数 std::cout << "Derived class show function." << std::endl; }
}; void display(Base* b) { b->show(); // 根据对象类型调用相应的函数
} int main() { Base base; Derived derived; display(&base); // 输出: Base class show function. display(&derived); // 输出: Derived class show function. return 0;
}4.抽象：
抽象是一个简化过程，它使得只关注对象的必要特征而忽略不相关的细节。通过抽象，可以设计出更高层次的结构，提供简单的接口，将复杂性封装在内部。
抽象可以通过纯虚函数和抽象类来实现。一个类如果包含一个或多个纯虚函数，则称为抽象类，该类无法被实例化。
优点：
- 隐藏复杂性：提供简单的接口，用户无需了解内部细节。
- 支持模块化设计：增强代码的可维护性和可读性。
示例：
class Shape {
public: virtual void draw() = 0; // 纯虚函数
}; class Circle : public Shape {
public: void draw() override { std::cout << "Drawing a circle." << std::endl; }
}; class Square : public Shape {
public: void draw() override { std::cout << "Drawing a square." << std::endl; }
}; int main() { Circle circle; Square square; Shape* shapes[] = { &circle, &square }; for (Shape* shape : shapes) { shape->draw(); // 根据具体形状调用相应的 draw 方法 } return 0;
}9.总结
类的定义涉及到成员变量、成员函数、构造函数、析构函数和访问修饰符等各个方面。理解这些概念是掌握C++面向对象编程的基础，有助于设计和实现高效、可维护的代码结构。类的四个基本特征（封装、继承、多态、抽象）共同构成了面向对象编程的核心思想，帮助开发者构建模块化、易于维护和扩展的系统。理解这些特性，可以有效地运用C++进行复杂的应用开发。
