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

C++从入门到精通（视频教程）

java 2025/9/6 18:06:05

## 概述

  • C++ 是一门兼具高效性能与面向对象特性的编程语言，广泛应用于游戏开发、系统编程、嵌入式开发、高性能计算等领域。
  • 视频教程：https://pan.quark.cn/s/39307b68d18f

第一阶段：入门基础（建立语法认知）

目标：理解 C++ 基本语法、编译运行流程，能编写简单的控制台程序（如计算、判断、循环类任务）。

1. 前置知识：计算机基础

在学习 C++ 前，需掌握以下基础概念，避免后续理解障碍：

  • 计算机硬件：CPU（运算/控制）、内存（临时存储数据）、硬盘（持久化存储）的分工。
  • 操作系统：文件系统（路径、文件夹）、命令行（Windows 的 cmd/PowerShell、Linux 的 bash）基础操作（如 cd 切换目录、dir/ls 查看文件）。
  • 编程语言本质：代码是“人类写给计算机的指令”，需通过编译器（如 GCC、Clang、MSVC）翻译成机器能识别的二进制指令。

2. 环境搭建：选择编译器与 IDE

工欲善其事，必先利其器。推荐新手选择“开箱即用”的 IDE，避免陷入复杂的环境配置：

工具类型推荐工具优势适用场景
集成开发环境（IDE）Dev-C++（轻量）体积小、安装简单，自带 MinGW 编译器纯新手入门（Windows）
Code::Blocks（跨平台）开源免费，支持 Windows/Linux/macOS入门到进阶过渡
Visual Studio 2022（专业）功能强大，调试工具完善，支持大型项目长期学习、Windows 开发
编译器+编辑器GCC/Clang + VS Code轻量灵活，跨平台，需手动配置插件熟悉基础后，追求自定义环境

操作步骤（以 Visual Studio 为例）：

  1. 下载 Visual Studio 2022 社区版（免费，官网链接）；
  2. 安装时勾选“使用 C++ 的桌面开发”组件；
  3. 新建项目：选择“控制台应用”，命名后自动生成含 main 函数的模板代码；
  4. 点击“本地 Windows 调试器”，即可编译运行程序。

3. 核心语法：从“Hello World”开始

掌握以下基础语法，能完成简单的逻辑编写：

（1）程序入口：main 函数

C++ 程序从 main 函数开始执行，无 main 函数则无法运行。

#include <iostream>  // 包含输入输出流库（用于 cout）// main 函数：程序入口，返回值为 int（表示程序运行状态）
int main() {std::cout << "Hello World!" << std::endl;  // 输出内容到控制台return 0;  // 返回 0 表示程序正常结束（非 0 表示异常）
}
（2）变量与数据类型

变量是“内存中的容器”，需先声明类型再使用。C++ 基本数据类型分为两类：

  • 基本内置类型：

    • 整数：int（4字节，范围约 ±21亿）、short（2字节）、long（4/8字节）、long long（8字节）；
    • 浮点数：float（4字节，精度低）、double（8字节，精度高，默认用 double）；
    • 字符：char（1字节，存储 ASCII 字符，如 'a'、'1'）；
    • 布尔：bool（1字节，值为 true（真）或 false（假））。

  • 变量声明与初始化：

    int age = 20;          // 直接初始化
double score;          // 先声明，后赋值
score = 95.5;
bool is_pass = (score >= 60);  // 布尔变量：true
char grade = 'A';      // 字符用单引号包裹
（3）输入输出：cin 与 cout

需包含头文件 <iostream>，使用 std 命名空间（避免命名冲突）：

#include <iostream>
using namespace std;  // 声明使用 std 命名空间，后续可省略 std::int main() {int a, b;cout << "请输入两个整数：";  // 输出提示cin >> a >> b;              // 从控制台读取两个整数，存入 a 和 bcout << "两数之和：" << a + b << endl;  // 输出结果return 0;
}
（4）控制流：判断与循环

  • 判断语句：if-else、switch

    int score = 85;
if (score >= 90) {cout << "优秀" << endl;
} else if (score >= 70) {cout << "良好" << endl;
} else {cout << "及格/不及格" << endl;
}

  • 循环语句：for（已知次数）、while（未知次数）、do-while（至少执行一次）

    // for 循环：打印 1~10
for (int i = 1; i <= 10; i++) {cout << i << " ";
}// while 循环：计算 1~100 的和
int sum = 0, n = 1;
while (n <= 100) {sum += n;n++;
}
cout << "sum = " << sum << endl;
（5）函数：代码复用的基础

函数是“封装好的代码块”，可接收参数、返回结果，避免重复编写。

// 函数声明：求两数之和（返回值类型 + 函数名 + 参数列表）
int add(int x, int y);int main() {int a = 3, b = 5;int result = add(a, b);  // 函数调用cout << "3 + 5 = " << result << endl;  // 输出 8return 0;
}// 函数定义：实现函数逻辑
int add(int x, int y) {return x + y;  // 返回计算结果
}

4. 入门实践：小项目练手

基础语法学完后，通过简单项目巩固：

  1. 计算器：支持加减乘除、括号优先级（用 switch 处理运算符，while 循环实现连续计算）；
  2. 猜数字游戏：程序随机生成 1~100 的数，用户猜，提示“大了”“小了”，直到猜对；
  3. 成绩统计：输入 N 个学生的成绩，计算平均分、最高分、最低分（用数组存储成绩）。

第二阶段：进阶核心（掌握 C++ 特有特性）

目标：理解 C++ 与 C 语言的差异（如面向对象、模板），掌握内存管理、引用、类与对象等核心概念，能编写模块化程序。

1. 核心概念：突破难点

（1）引用（&）：变量的“别名”

引用不是新变量，而是对已有变量的“别名”，常用于函数参数（避免拷贝）和返回值。

#include <iostream>
using namespace std;// 引用作为参数：直接修改原变量（无需指针）
void swap(int &x, int &y) {int temp = x;x = y;y = temp;
}int main() {int a = 10, b = 20;swap(a, b);  // 调用后 a=20，b=10（修改原变量）cout << "a = " << a << ", b = " << b << endl;return 0;
}

注意：引用必须初始化（不能“悬空”），且初始化后不能指向其他变量。

（2）指针（*）：存储内存地址

指针是“存储内存地址的变量”，是 C++ 操作内存的核心工具（如动态内存分配、数组访问）。

int main() {int num = 100;int *p = &num;  // p 是指针变量，存储 num 的内存地址（& 是取地址符）cout << "num 的值：" << num << endl;       // 100cout << "num 的地址：" << &num << endl;    // 0x61fe14（示例地址）cout << "p 存储的地址：" << p << endl;     // 0x61fe14（与 &num 相同）cout << "p 指向的值：" << *p << endl;      // 100（* 是解引用符，获取地址对应的值）*p = 200;  // 通过指针修改原变量的值cout << "修改后 num 的值：" << num << endl;  // 200return 0;
}

常用场景：动态内存分配（new/delete）、函数参数传递（修改指针指向的变量）、数组（数组名本质是指向首元素的指针）。

（3）动态内存管理：new 与 delete

C++ 允许手动申请/释放内存（堆内存），需注意：申请后必须释放，否则会导致内存泄漏。

  • 申请单个变量：int *p = new int;（分配 4 字节内存，返回地址）；
  • 申请数组：int *arr = new int[5];（分配 5 个 int 的内存，共 20 字节）；
  • 释放内存：delete p;（释放单个变量）、delete[] arr;（释放数组，必须加 []）。
int main() {// 动态申请一个 int 变量int *p = new int;*p = 50;cout << *p << endl;  // 50delete p;  // 释放内存，避免泄漏// 动态申请一个数组int *arr = new int[3];for (int i = 0; i < 3; i++) {arr[i] = i + 1;  // 数组访问：arr[i] 等价于 *(arr + i)}delete[] arr;  // 释放数组，必须加 []return 0;
}
（4）类与对象：面向对象编程（OOP）

C++ 的核心思想是“面向对象”，通过类（Class） 封装数据和行为，通过对象（Object） 实例化类。

  • 类的定义：用 class 关键字，包含“成员变量”（数据）和“成员函数”（行为）；
  • 访问控制：public（外部可访问）、private（仅类内部可访问）、protected（类内部及子类可访问）；
  • 构造函数：创建对象时自动调用，用于初始化成员变量（无返回值，函数名与类名相同）；
  • 析构函数：对象销毁时自动调用，用于释放资源（无返回值，函数名前加 ~）。

示例：定义一个 Student 类，实现学生信息的存储与打印：

#include <iostream>
#include <string>  // 用于 string 类型
using namespace std;// 定义 Student 类
class Student {
private:// 私有成员变量：外部无法直接访问string name;int age;double score;public:// 构造函数（无参）Student() {name = "未知";age = 0;score = 0.0;}// 构造函数（带参，重载）Student(string n, int a, double s) {name = n;age = a;score = s;}// 析构函数（无参）~Student() {cout << name << " 的对象已销毁" << endl;}// 公有成员函数：外部通过函数访问私有变量void setInfo(string n, int a, double s) {name = n;age = a;score = s;}void showInfo() {cout << "姓名：" << name << endl;cout << "年龄：" << age << endl;cout << "成绩：" << score << endl;}
};int main() {// 创建对象 1：调用无参构造函数Student stu1;stu1.setInfo("张三", 18, 92.5);stu1.showInfo();  // 打印张三的信息// 创建对象 2：调用带参构造函数Student stu2("李四", 19, 88.0);stu2.showInfo();  // 打印李四的信息return 0;
}
（5）模板（Template）：泛型编程

模板是“代码的模板”，允许编写与类型无关的代码，实现泛型编程（如 STL 容器的底层）。分为函数模板和类模板。

示例：用函数模板实现“交换任意类型变量”（无需为 int、double 分别写 swap 函数）：

#include <iostream>
using namespace std;// 函数模板：T 是“类型参数”，可替换为任意类型
template <typename T>
void swap(T &x, T &y) {T temp = x;x = y;y = temp;
}int main() {int a = 10, b = 20;swap(a, b);  // T 自动推导为 int，交换整数cout << "a = " << a << ", b = " << b << endl;  // 20, 10double c = 3.14, d = 6.28;swap(c, d);  // T 自动推导为 double，交换浮点数cout << "c = " << c << ", d = " << d << endl;  // 6.28, 3.14return 0;
}

2. 标准模板库（STL）：提高开发效率

STL 是 C++ 内置的“工具库”，包含容器（存储数据）、算法（操作数据）、迭代器（遍历容器），是进阶阶段必须掌握的核心工具。

常用容器及场景
容器类型具体容器特点适用场景
序列容器vector动态数组，支持随机访问，尾部插入高效存储列表数据（如成绩、日志）
list双向链表，插入/删除高效，不支持随机访问频繁插入/删除的场景
关联容器map键值对（key-value），按键排序，无重复键字典、索引（如姓名-成绩映射）
unordered_map键值对，哈希存储，查找速度快高频查找场景（如缓存）
容器适配器stack栈（先进后出，LIFO）括号匹配、表达式求值
queue队列（先进先出，FIFO）任务调度、消息队列

示例：用 vector 存储学生成绩，计算平均分：

#include <iostream>
#include <vector>   // 包含 vector 容器
#include <algorithm> // 包含 sort 算法
using namespace std;int main() {// 创建 vector 容器，存储 double 类型的成绩vector<double> scores;// 向容器尾部添加元素（push_back）scores.push_back(95.5);scores.push_back(88.0);scores.push_back(92.0);scores.push_back(76.5);// 遍历容器：用迭代器（iterator）double sum = 0.0;for (vector<double>::iterator it = scores.begin(); it != scores.end(); it++) {sum += *it;  // *it 获取迭代器指向的元素}// 计算平均分double avg = sum / scores.size();  // size() 获取容器元素个数cout << "平均分：" << avg << endl;  // 88.0// 排序：调用 sort 算法（升序）sort(scores.begin(), scores.end());cout << "排序后成绩：";for (double s : scores) {  // 范围 for 循环（C++11 及以上）cout << s << " ";  // 76.5 88.0 92.0 95.5}return 0;
}

3. 进阶实践：模块化项目

  1. 学生信息管理系统：用 class 定义 Student 类，vector 存储学生对象，实现“添加、查询、修改、删除、排序”功能；
  2. 简易通讯录：用 map 存储“姓名-电话”键值对，实现“添加联系人、查找联系人、删除联系人”功能；
  3. 栈实现括号匹配：用 stack 容器，遍历字符串，遇到左括号入栈，遇到右括号出栈匹配，判断是否合法。

第三阶段：精通深化（工程化与底层能力）

目标：理解 C++ 底层原理（如内存模型、虚函数表），掌握设计模式、性能优化、跨平台开发，能编写高可用、高性能的工程级代码。

1. 底层原理：看透 C++ 的“本质”

（1）内存模型：栈、堆、全局区、常量区

C++ 程序运行时，内存分为 4 个区域，不同区域的变量有不同的生命周期：

  • 栈区（Stack）：存储局部变量、函数参数，由编译器自动分配/释放（函数调用时分配，函数返回时释放），大小固定（通常几 MB）；
  • 堆区（Heap）：由程序员手动分配/释放（new/delete），大小灵活（可到 GB 级），需注意内存泄漏；
  • 全局区（静态区）：存储全局变量、静态变量（static），程序启动时分配，程序结束时释放；
  • 常量区：存储字符串常量（如 "Hello"）、const 常量，程序结束时释放。
（2）虚函数与多态：面向对象的核心

多态是“同一行为，不同实现”，通过虚函数（virtual） 实现，底层依赖“虚函数表（vtable）”。

  • 当子类重写父类的虚函数时，父类指针/引用指向子类对象，调用函数时会自动执行子类的实现（动态绑定）；
  • 非虚函数：调用时根据指针/引用的“类型”执行（静态绑定），不支持多态。

示例：多态实现“动物叫”：

#include <iostream>
using namespace std;// 父类：Animal
class Animal {
public:// 虚函数：允许子类重写virtual void speak() {cout << "动物在叫" << endl;}// 虚析构函数：确保子类对象销毁时调用子类析构函数virtual ~Animal() {cout << "Animal 析构" << endl;}
};// 子类：Dog（继承 Animal）
class Dog : public Animal {
public:// 重写父类的虚函数void speak() override {  // override 关键字：显式声明重写，避免错误cout << "汪汪汪" << endl;}~Dog() {cout << "Dog 析构" << endl;}
};// 子类：Cat（继承 Animal）
class Cat : public Animal {
public:void speak() override {cout << "喵喵喵" << endl;}~Cat() {cout << "Cat 析构" << endl;}
};// 函数：接收 Animal 引用，调用 speak（多态体现）
void animalSpeak(Animal &animal) {animal.speak();
}int main() {Dog dog;Cat cat;animalSpeak(dog);  // 输出“汪汪汪”（子类实现）animalSpeak(cat);  // 输出“喵喵喵”（子类实现）// 父类指针指向子类对象（多态的经典场景）Animal *p1 = new Dog();Animal *p2 = new Cat();p1->speak();  // 汪汪汪p2->speak();  // 喵喵喵// 释放内存：虚析构函数确保子类析构被调用delete p1;  // Dog 析构 → Animal 析构delete p2;  // Cat 析构 → Animal 析构return 0;
}
（3）C++11 及以上新特性

现代 C++（C++11/14/17/20）引入了大量简化开发、提升性能的特性，必须掌握：

  • 智能指针：unique_ptr、shared_ptr、weak_ptr，自动管理内存，避免内存泄漏（替代手动 new/delete）；
  • 范围 for 循环：for (auto x : container)，简化容器遍历；
  • Lambda 表达式：匿名函数，常用于算法参数（如 sort 自定义排序规则）；
  • nullptr：替代 NULL，避免空指针歧义；
  • auto 关键字：自动推导变量类型，简化代码（如 auto it = scores.begin()）。

示例：用 shared_ptr 智能指针管理动态内存：

#include <iostream>
#include <memory>  // 包含智能指针
using namespace std;class Student {
public:Student(string name) : name(name) {cout << name << " 构造" << endl;}~Student() {cout << name << " 析构" << endl;}
private:string name;
};int main() {// 创建 shared_ptr 智能指针，自动管理 Student 对象shared_ptr<Student> p1 = make_shared<Student>("张三");  // 推荐用 make_shared 创建shared_ptr<Student> p2 = p1;  // 共享所有权（引用计数+1）cout << "引用计数：" << p1.use_count() << endl;  // 2（p1 和 p2 都指向该对象）// p1 释放指向（引用计数-1）p1.reset();cout << "引用计数：" << p2.use_count() << endl;  // 1// 程序结束时，p2 销毁，引用计数-1 变为 0，自动调用析构函数（无内存泄漏）return 0;
}

2. 工程化能力：编写可维护的代码

（1）代码规范
  • 命名规范：类名用 PascalCase（如 StudentManager），函数/变量用 camelCase（如 showInfo），常量用 UPPER_SNAKE_CASE（如 MAX_SCORE）；
  • 注释规范：类/函数用“文档注释”（如 /// <summary> 计算平均分 </summary>），复杂逻辑用行注释（// 此处处理异常情况）；
  • 文件组织：类的声明放在 .h 头文件，实现放在 .cpp 源文件（如 Student.h 声明类，Student.cpp 实现成员函数），避免头文件重复包含（用 #ifndef/#define/#endif 或 #pragma once）。
（2）设计模式

设计模式是“解决特定问题的成熟方案”，常用模式：

  • 单例模式：确保一个类只有一个实例（如配置管理器、日志管理器）；
  • 工厂模式：隐藏对象创建逻辑，统一创建接口（如 AnimalFactory 生成 Dog/Cat 对象）；
  • 观察者模式：对象状态变化时，自动通知依赖它的对象（如 GUI 事件监听）；
  • 策略模式：定义算法家族，动态切换算法（如排序算法可切换 冒泡排序/快速排序）。
（3）调试与性能优化
  • 调试工具：用 Visual Studio 的“断点调试”（查看变量值、调用栈）、GDB（Linux 下命令行调试）；
  • 性能优化：减少拷贝（用引用/移动语义）、避免内存泄漏（用智能指针）、优化循环（减少循环内的计算）、使用 const 修饰只读变量/函数（帮助编译器优化）。

3. 精通实践：工程级项目

  1. 日志系统：支持控制台输出、文件输出，按级别（DEBUG/INFO/WARN/ERROR）过滤日志，用单例模式确保全局唯一日志实例；
  2. 简易 HTTP 服务器：基于 socket 编程，处理客户端的 HTTP 请求（如 GET 请求），返回 HTML 页面；
  3. 游戏核心模块：用面向对象设计角色（Player/Enemy 继承 Role 类），用策略模式实现不同角色的攻击方式，用 vector/map 管理游戏对象。

学习资源推荐

  1. 书籍：
    • 入门：《C++ Primer Plus》（第 6 版）：语法讲解详细，适合新手；
    • 进阶：《C++ Primer》（第 5 版）：深入 C++ 核心特性，权威教材；
    • 精通：《Effective C++》（第 3 版）：55 条提高 C++ 代码质量的准则；《深度探索 C++ 对象模型》：剖析 C++ 底层实现。
  2. 视频：
    • 入门：B站“黑马程序员 C++ 教程”（免费，适合零基础）；
    • 进阶：Coursera“C++ For C Programmers”（斯坦福大学，深入 C++ 特性）；
  3. 刷题：
    • 平台：LeetCode（用 C++ 刷算法题，巩固语法与逻辑）、牛客网（C++ 专项练习）；
    • 推荐题目：LeetCode 1（两数之和）、LeetCode 20（有效的括号）、LeetCode 102（二叉树的层序遍历）。

总结

C++ 学习是“量变到质变”的过程：

  • 入门阶段：重点掌握语法，通过小项目建立“代码感”；
  • 进阶阶段：突破核心特性（类、模板、STL），实现模块化编程；
  • 精通阶段：理解底层原理，掌握工程化能力，能解决复杂问题。

关键是“多写多练”——语法学完后立即实践，遇到问题（如内存泄漏、编译错误）时，通过调试、查文档、逛论坛（Stack Overflow、CSDN）解决，逐步积累经验，最终实现从“会写代码”到“写好代码”的跨越。

http://www.xdnf.cn/news/20326.html

相关文章：

  • More Effective C++ 条款30：代理类
  • 2025高中文凭能考的证书大全
  • 2021/07 JLPT听力原文 问题一 4番
  • 第八章 惊喜05 笑笑点评团队
  • Claude Code成本浪费严重？80%开支可省！Token黑洞解密与三层省钱攻略
  • 使用YOLO11训练鸟类分类模型
  • AI应用开发-技术架构 PAFR介绍
  • JS魔法中介：Proxy和Reflect为何形影不离？
  • 【1】MOS管的结构及其工作原理
  • Linux系统： docker安装RagFlow教程
  • 【工具变量】上市公司企业海外业务收入数据集（2003-2024年）
  • C++ map和set
  • 2025年经济学专业女生必考证书指南：打造差异化竞争力
  • Netty从0到1系列之JDK零拷贝技术
  • Spring DI详解--依赖注入的三种方式及优缺点分析
  • Windows 权限提升(一)
  • ES模块（ESM）、CommonJS（CJS）和UMD三种格式
  • Java全栈学习笔记30
  • RX 9 Audio Editor 音频编辑器安装教程（v9.3.0 Windows版）
  • if __name__=‘__main__‘的用处
  • 推荐收藏！5款低代码工具，告别复杂开发！
  • 8051单片机-蜂鸣器
  • 数据库索引结构 B 树、B + 树与哈希索引在不同数据查询场景下的适用性分析
  • vue-amap组件呈现的效果图如何截图
  • 米尔RK3576部署端侧多模态多轮对话,6TOPS算力驱动30亿参数LLM
  • MySQL数据库基础(DCL,DDL,DML)详解
  • Axure笔记
  • 【VoNR】VoNR是5G语音，VoLTE是4G语音，他们是同一个IMS，只是使用了新的访问方式？
  • 传统神经网络实现-----手写数字识别（MNIST）项目
  • 状压 dp --- 棋盘覆盖问题