当前位置：首页 > news >正文

C++ 学习 C++独有的核心特性 2025年6月16日18:11:04

news 来源：原创 2025/6/17 10:43:36

C++独有的核心特性

1. 面向对象编程（OOP）

类与对象：class、public/private访问控制、成员函数。
构造函数/析构函数：对象的初始化和清理。
继承与多态：virtual函数、抽象类、override。

override关键字和 virtual 代码示例:

//   virtual(动态绑定) 虚函数声明#include <iostream>  // 包含标准输入输出流库
using namespace std; // 使用标准命名空间（避免每次写std::）// 定义一个动物基类
class Animal {
public:// 虚函数：允许子类重写这个函数// virtual关键字表示这个函数支持"运行时多态"virtual void speak() { cout << "动物叫\n";  // 基类默认实现}  // 虚析构函数：确保通过基类指针删除子类对象时能正确调用子类析构函数virtual ~Animal() {}
};// 定义Dog类，继承自Animal
class Dog : public Animal {
public:// override关键字(C++11)：// 1. 明确表示这是重写父类的虚函数// 2. 如果父类没有这个虚函数，编译器会报错void speak() override { cout << "汪汪！\n";  // 子类特有实现}// 子类析构函数//类名前面加 ~ 是 C++ 中 析构函数 的固定语法（如 ~Dog()）//当 Dog 对象被销毁时自动调用，用于 清理资源（如释放内存、关闭文件等）~Dog() {cout << "Dog对象被销毁\n"; //直接输出，无需格式 c++专属写法//标准输出流对象（位于 <iostream> 头文件中）//<<：流插入运算符，表示“输出到 cout”。}
};int main() {// 创建一个Dog对象，但用Animal指针指向它// 这是面向对象编程中"父类指针指向子类对象"的典型用法Animal* pet = new Dog();  // 调用speak()函数：// 因为有virtual关键字，所以会根据实际对象类型(Dog)调用对应的函数// 这就是"运行时多态"的表现pet->speak();  // 输出"汪汪！"// 删除对象：// 因为Animal有虚析构函数，所以会先调用~Dog()，再调用~Animal()//delete pet 会先调用 Dog 的析构函数 ~Dog()（因为 Animal 的析构函数是 virtual 的）delete pet;return 0;
}

抽象类:

抽象类是 C++ 中一种特殊的类，它用于定义接口和规范子类的行为。

什么是抽象类？纯虚函数的语法:在虚函数声明后加 = 0

//纯虚函数格式
virtual 返回类型 函数名(参数) = 0;//抽象类格式
class Shape {  // 抽象类
public:virtual double area() const = 0;  // 纯虚函数virtual ~Shape() {}               // 虚析构函数
};

定义：包含至少一个纯虚函数（Pure Virtual Function）的类。
特点：
- 不能直接实例化（不能创建对象）。
- 必须通过子类继承并实现所有纯虚函数后才能使用。
作用：
- 强制子类实现特定功能。
- 提供统一的接口规范。

抽象类的使用

子类必须实现所有纯虚函数，否则也会成为抽象类。
用途：
- 设计模式中的接口（如工厂模式、策略模式）。
- 框架设计中定义规范。

#include <iostream>
using namespace std;// 抽象类：图形
class Shape {
public:virtual double area() const = 0;  // 纯虚函数virtual void print() const {      // 普通虚函数（可选实现）cout << "这是一个图形" << endl;}virtual ~Shape() {}               // 虚析构函数
};// 子类：圆形
class Circle : public Shape {
private:  //成员类型 成员名称;
//访问修饰符，表示后续成员是私有的（只能在类内部访问）。
//冒号 : 是语法要求，表示访问权限的开始。double radius;
public:Circle(double r) : radius(r) {}double area() const override {    // 必须实现纯虚函数return 3.14159 * radius * radius;}void print() const override {     // 重写普通虚函数cout << "这是一个圆形，面积：" << area() << endl;}
};int main() {// Shape s;  // 错误！不能实例化抽象类Shape* shape = new Circle(5.0);  // 通过指针使用shape->print();delete shape;return 0;
}//调用结果
这是一个圆形，面积：78.5397

基础代码示例

class Animal {
public:virtual void speak() = 0; // 纯虚函数（抽象类）
};
class Dog : public Animal {
public:void speak() override { cout << "Woof!"; }
};

2.引用（Reference）

本质是别名，比指针更安全。

基础代码示例

int a = 10;
int& ref = a;  // ref是a的引用
ref = 20;      // 直接修改a的值

3.函数重载（Overloading）

同名函数根据参数类型/数量区分。

基础代码示例

void print(int x) { /*...*/ }
void print(double x) { /*...*/ }

C++标准库（STL）

1.容器（Containers）

顺序容器：vector（动态数组）、list（链表）、deque（双端队列）。
关联容器：map（红黑树）、unordered_map（哈希表)

示例代码:

std::vector<int> nums = {1, 2, 3};
nums.push_back(4); // 自动扩容

2. 算法（Algorithms）

泛型操作：sort、find、transform。

示例代码:

std::sort(nums.begin(), nums.end()); // 排序

3.智能指针（Smart Pointers）

自动内存管理：unique_ptr、shared_ptr。

示例代码:

std::shared_ptr<int> ptr = std::make_shared<int>(42);

C++与C的差异点

特性	C	C++
内存管理	`malloc/free`	`new/delete` + 智能指针
字符串	`char[]`	`std::string`（自动管理内存）
错误处理	返回错误码	`try/catch`异常机制
泛型编程	无	模板（`template`）

进阶特性

1.模板（Templates）

泛型编程：函数模板和类模板。

代码示例:

template <typename T>
T max(T a, T b) { return a > b ? a : b; }

2.Lambda表达式

匿名函数，简化回调。

代码示例:

auto sum = [](int a, int b) { return a + b; };

3.移动语义（C++11）

std::move、右值引用，提升性能。

代码示例:

std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = std::move(v1); // v1的资源被转移

特殊语法和操作符

1. 成员访问操作符：`->` 和 `::`

`->` 操作符

在C中：仅用于结构体指针访问成员（ptr->member）。
在C++中：
- 除了用于类和结构体指针，还可以被重载（如智能指针、迭代器）。
- 用于访问对象的成员函数或数据成员。

代码示例:

class MyClass {
public:void print() { std::cout << "Hello"; }
};MyClass obj;
MyClass* ptr = &obj;
ptr->print();  // 等价于 (*ptr).print()

`::` 作用域解析符

访问全局变量（当局部变量同名时）：

代码示例:

int x = 10;
void foo() {int x = 20;std::cout << ::x; // 输出全局的x（10）
}

访问类的静态成员:

代码示例:

class MyClass {
public:static int count;
};
int MyClass::count = 0; // 静态成员定义

2. 初始化列表（Initializer List）

C++11引入的统一初始化语法：

// C++11之后的初始化方式
std::vector<int> nums = {1, 2, 3};  // 初始化列表
int arr[]{1, 2, 3};                 // 数组初始化
class Point {
public:Point(int x, int y) : x_(x), y_(y) {} // 成员初始化列表
private:int x_, y_;
};

3.范围`for`循环（Range-based for loop）

C++11新增的简化遍历语法：

std::vector<int> nums = {1, 2, 3};
for (int num : nums) {  // 遍历容器std::cout << num;
}

`4.auto` 类型推导

自动推断变量类型（C++11）：

auto x = 10;      // x是int
auto str = "C++"; // str是const char*
auto ptr = std::make_shared<int>(42); // ptr是std::shared_ptr<int>

`5.nullptr` 替代 `NULL`

C++11引入的空指针常量，类型安全：

int* ptr = nullptr;  // 推荐用法（C++11+）
if (ptr == nullptr) { /*...*/ }

6.运算符重载（Operator Overloading）

允许自定义操作符行为：

class Vector {
public:Vector operator+(const Vector& other) {return Vector(x + other.x, y + other.y);}int x, y;
};
Vector v1{1, 2}, v2{3, 4};
Vector v3 = v1 + v2; // 调用重载的+

`7.``using` 替代 `typedef`（C++11）

更直观的类型别名：

using IntVector = std::vector<int>; // C++11
typedef std::vector<int> IntVector; // C风格（仍可用）

8.结构化绑定（C++17）

解包结构体或元组：

std::pair<int, std::string> p{1, "C++"};
auto [id, name] = p; // id=1, name="C++"

9.三向比较符 `<=>`（C++20）

简化比较操作：

auto cmp = (a <=> b);
if (cmp < 0)  { /* a < b */ }
else if (cmp == 0) { /* a == b */ }
else { /* a > b */ }

C vs C++特殊语法

语法	C	C++
`->`	仅用于结构体指针	可重载（如智能指针、迭代器）
`::`	无	访问全局变量、命名空间、类静态成员
初始化	`int arr[3] = {1, 2, 3};`	`std::vector<int> nums{1, 2, 3};`
`auto`	无	自动类型推导（C++11）
`nullptr`	使用`NULL`（通常是0）	类型安全的空指针（C++11）
Lambda	无	支持匿名函数（C++11）