异常教程

C++ 测验（手把手讲解）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

在编程学习的旅程中，C++ 作为一门兼具底层控制力与高效性的语言，始终占据着重要地位。无论是开发系统软件、游戏引擎，还是高性能计算工具，C++ 的特性使其成为开发者不可忽视的技能。然而，C++ 的复杂语法和细节也常常让学习者感到挑战重重。通过精心设计的 C++ 测验，开发者可以系统性地检验知识掌握程度，发现认知盲区，并通过针对性练习巩固核心概念。本文将从基础语法、内存管理、面向对象特性等维度出发，结合实际案例与代码示例，帮助读者逐步构建扎实的 C++ 基础。

一、C++ 基础语法与核心概念

1.1 变量作用域与命名空间

变量作用域决定了代码块中变量的可见范围，是避免命名冲突的关键。C++ 提供了 块级作用域（{} 包裹的代码块）、函数作用域 和 文件作用域。例如：

// 文件作用域变量  
int globalVar = 10;  

void func() {  
    int localVar = 20; // 函数作用域变量  
    {  
        int blockVar = 30; // 块级作用域变量  
        std::cout << blockVar << std::endl;  
    }  
    // std::cout << blockVar; // 错误：blockVar 已超出作用域  
}

命名空间（namespace） 则用于逻辑隔离不同模块的代码。通过 using namespace 可以简化代码，但过度使用可能导致命名冲突。例如：

namespace Math {  
    const double PI = 3.14159;  
}  

int main() {  
    std::cout << Math::PI << std::endl; // 明确指定命名空间  
    return 0;  
}

1.2 运算符优先级与类型转换

C++ 的运算符优先级可能引发意外结果，需通过括号明确表达式顺序。例如：

int a = 5 + 3 * 2; // 结果为 11（乘法优先级高于加法）  
int b = (5 + 3) * 2; // 结果为 16

类型转换 包括隐式转换（如 int 赋值给 double）和显式转换（如 static_cast）。隐式转换可能导致精度丢失，需谨慎使用。例如：

double d = 10 / 3; // 结果为 3.0，因 10 和 3 是整数，运算结果截断  
d = static_cast<double>(10) / 3; // 结果为 3.333...

二、内存管理与指针

2.1 指针与引用的区别

指针是存储内存地址的变量，而引用是变量的别名。指针可以 nullptr 或重新赋值，但引用一旦初始化后不可更改。例如：

int num = 10;  
int* ptr = &num; // 指向 num 的地址  
int& ref = num; // ref 是 num 的别名  

ptr = nullptr; // 合法  
// ref = 20; // 错误：引用不可重新绑定

比喻：指针像地图上的标记，可以指向不同位置；而引用像给朋友起的昵称，只能指向一个对象。

2.2 动态内存管理与内存泄漏

new 和 delete 用于动态分配和释放内存，未正确释放会导致内存泄漏。例如：

int* arr = new int[5]; // 分配 5 个整数空间  
delete[] arr; // 必须用 delete[] 释放数组

智能指针（如 std::unique_ptr）可自动管理内存，避免手动释放：

std::unique_ptr<int[]> smartArr = std::make_unique<int[]>(5);  
// 使用后无需 delete，离开作用域自动释放

2.3 指针算术与数组

指针算术允许通过地址偏移访问数组元素：

int arr[] = {1, 2, 3};  
int* p = arr; // 指向数组首元素  
std::cout << *(p + 1) << std::endl; // 输出 2

但越界访问（如 p[3]）会导致未定义行为，需严格控制索引范围。

三、面向对象与多态性

3.1 类与对象的关系

类（Class）是对象的模板，定义数据成员和成员函数。例如：

class Rectangle {  
private:  
    int width, height;  
public:  
    void setDimensions(int w, int h) {  
        width = w;  
        height = h;  
    }  
    int area() const {  
        return width * height;  
    }  
};  

int main() {  
    Rectangle rect;  
    rect.setDimensions(4, 5);  
    std::cout << rect.area() << std::endl; // 输出 20  
    return 0;  
}

3.2 继承与多态

继承 允许子类继承父类的属性和方法：

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; }  
};  

int main() {  
    Shape* shape = new Circle();  
    shape->draw(); // 输出 "Drawing Circle"（多态性）  
    delete shape;  
    return 0;  
}

虚函数（virtual） 是实现多态的关键，通过动态绑定调用子类方法。

3.3 运算符重载

运算符重载允许自定义类的行为，例如重载 << 输出对象：

class Vector2D {  
    int x, y;  
public:  
    Vector2D(int x_, int y_) : x(x_), y(y_) {}  
    friend std::ostream& operator<<(std::ostream& os, const Vector2D& v) {  
        return os << "(" << v.x << ", " << v.y << ")";  
    }  
};  

int main() {  
    Vector2D vec(3, 4);  
    std::cout << vec << std::endl; // 输出 "(3, 4)"  
    return 0;  
}

四、STL 与模板

4.1 容器与迭代器

标准模板库（STL）提供了丰富的容器，如 vector、map 等。例如：

#include <vector>  
#include <algorithm>  

int main() {  
    std::vector<int> vec = {5, 3, 8, 1};  
    std::sort(vec.begin(), vec.end()); // 排序为 [1, 3, 5, 8]  
    for (auto it = vec.begin(); it != vec.end(); ++it) {  
        std::cout << *it << " "; // 迭代器遍历  
    }  
    return 0;  
}

4.2 模板与泛型编程

模板允许编写通用函数或类：

template <typename T>  
T add(T a, T b) {  
    return a + b;  
}  

int main() {  
    std::cout << add(3, 5) << std::endl; // 整数  
    std::cout << add(1.5, 2.3) << std::endl; // 浮点数  
    return 0;  
}

五、C++11 新特性与现代实践

5.1 智能指针与 RAII

std::unique_ptr 和 std::shared_ptr 通过 RAII（资源获取即初始化）自动管理资源：

std::unique_ptr<int> uptr = std::make_unique<int>(10); // 独占所有权  
std::shared_ptr<int> sptr = std::make_shared<int>(20); // 共享所有权

5.2 Lambda 表达式

Lambda 可以快速定义匿名函数：

std::vector<int> nums = {1, 2, 3, 4};  
int sum = 0;  
std::for_each(nums.begin(), nums.end(), [&](int x) { sum += x; });  
std::cout << sum << std::endl; // 输出 10

六、常见陷阱与调试技巧

6.1 悬挂指针与野指针

当指针指向已释放的内存或未初始化时，访问会导致崩溃。例如：

int* ptr; // 未初始化，值未知  
delete ptr; // 可能引发未定义行为

6.2 调试工具与核心转储

使用 gdb 或 valgrind 检查内存泄漏：

valgrind --leak-check=full ./my_program

结论

通过系统化的 C++ 测验，开发者可以精准定位知识短板，逐步掌握从基础语法到高级特性的核心内容。本文通过代码示例与实际场景，剖析了作用域、内存管理、面向对象、STL 等关键知识点，帮助读者建立扎实的 C++ 基础。建议读者在学习过程中主动编写代码、参与测验，并结合调试工具优化代码质量。C++ 的学习是一个循序渐进的过程，唯有不断实践与反思，才能真正驾驭这门强大而复杂的语言。

最新发布

查看更多文章