简介：C++入门、核心与提高讲义笔记面向零基础到进阶的编程学习者，也适合作为课程配套资料和自学复习提纲，帮助读者把分散的语法知识串联成较完整的学习路径。包内为1个PDF文件，约5.07MB，将入门、核心、提高三阶段内容整合为一份便于检索的讲义笔记，适合按章节查阅和反复温习。已有25997人学习下载，具备较好的参考基础。内容从第一个C++程序、注释、变量与常量、关键字、标识符命名规则讲起，延伸到整型、浮点型、字符型等数据类型，并进一步覆盖指针、数组、结构体、类、运算符重载、模板和异常处理等核心与提高主题；配合示例代码和要点提示，可帮助读者理解概念、对照练习，并逐步建立面向对象与泛型编程的基础认知。

1. 先别看代码：C++ 入门讲义笔记到底是给谁准备的

很多人第一次搜「C++ 入门」，点开的第一篇文章开头就是指针、模板、内存泄漏，三行看完直接劝退。不是你看不懂，是那类文章默认你已经会一门编程语言了。这份 C++ 讲义笔记走的是另一条路：它把 C++ 这门编程语言最前面那段路单独铺平了，从怎么建一个项目、怎么写第一行输出，一路讲到变量、常量、数据类型、运算符，全部按「你一行代码都没写过」的节奏排。它适合三类人：完全零基础、想找一门编程语言打底的；学过一点 C 语言、想弄清 C++ 到底差在哪的；以及需要一份能随手翻的笔记当参考的。整份资料分入门、核心、提高三层，入门那部分，就是专门留给新手的落地内容。

2. 为什么零基础也值得学 C++：先搞清楚它是手动挡还是自动挡

2.1 一个类比：C++ 是手动挡，Python 是自动挡

学车的时候，自动挡踩着油门就能走，手动挡要管离合、管挡位，起步还容易熄火。但开过手动挡的人，对车是怎么跑起来的会有一个很具体的感受。编程语言也是这个道理：有些语言把内存、类型、编译这些事全替你藏起来，你写一行就出一行结果；C++ 不藏，它要求你说清楚这个数是整数还是小数、占几个字节、这块内存什么时候还回去。

麻烦是真的麻烦，收获也是真的收获。你写 C++ 的时候，屏幕上那个int a = 10;不是一个抽象符号，你会知道它在内存里占了 4 个字节，存的是 10 的二进制补码。这种「知道底下发生了什么」的直觉，是后面学任何一门语言都带得走的。所以零基础学 C++ 并不亏，它是那种开头慢、后面越走越稳的路子。

2.2 学完能干什么：四个还在大量用 C++ 的方向

不提那些听上去很远的词，就说具体的。第一类是底层软件，操作系统、数据库引擎、浏览器内核这类东西，对性能要求苛刻，很多核心模块仍然是 C++ 写的。第二类是游戏和图形，游戏引擎、渲染、物理模拟，这些场景一帧只有十几毫秒的预算，语言本身的开销必须压到最低。第三类是嵌入式和硬件相关，单片机、车载设备、工业控制板，内存可能只有几十 KB，跑不动庞大的运行时。第四类是高并发服务，交易系统、实时通信这类对延迟敏感的后台。

这四个方向的共同点是：它们都不允许程序「差不多就行」。C++ 的存在价值就在这里，它给你对内存和性能的直接控制权，代价是你必须自己承担这份责任。对新手来说，暂时不用纠结以后去哪个方向，先把语言本身跑通，选择权自然就来了。

2.3 C 语言和 C++ 的关系：别被两个名字绕晕

很多人搜「C++ 入门」的时候会顺带看到「C 语言入门」，然后陷入选择困难。简单说，C++ 是从 C 发展出来的，早期它甚至被叫做「带类的 C」，所以它保留了绝大部分 C 的语法。你在讲义里会看到两种风格的字符串：char str[] = "hello";是 C 风格，string str = "hello";是 C++ 风格；定义常量也有两种写法：#define DAY 7是 C 的预处理宏，const int month = 12;是 C++ 更推荐的方式。

这意味着两件事。好消息是，学 C++ 的过程中你顺带就把 C 的常用语法看懂了，以后遇到 C 代码不会发怵。需要注意的是，别在入门阶段纠结「这段到底是 C 还是 C++」，讲义把两种写法都列出来，是为了让你以后读别人的代码时不至于愣住，不是为了让你现在就做学术区分。先用起来，风格问题以后自然会有判断。

2.4 这份讲义的三层结构，为什么刚好卡在新手的节奏上

这份笔记的编排是「入门、核心、提高」三层。入门层讲的是初识、数据类型、运算符，也就是怎么让程序跑起来、怎么存数据、怎么算数；核心层进入指针、数组、函数、结构体、类、运算符重载，解决的是「怎么把一堆数据和操作组织在一起」；提高层才轮到模板、异常处理、设计模式这些偏抽象的內容。

这个顺序对新手友好，是因为它符合「先能跑、再能存、再能算、最后能组织」的认知节奏。很多教程翻车就翻在顺序上：一上来讲面向对象，你连变量是什么都不知道，听「类是对一类事物的抽象」当然像听天书。而这份讲义把最枯燥但最必要的部分放在最前面，先用大量小例子让你建立手感，等手感有了，再谈抽象。

2.5 前置知识其实只有三样，缺了也能补

第一样，会在电脑上建文件夹、找文件、改文件名。因为你要创建项目、保存源文件，这些都是文件操作。第二样，会正常打字，包括英文的括号、分号、引号。这件事听起来好笑，但新手第一个编译错误里，有一半是中文标点造成的。第三样，不怕看见英文报错。编译器报错信息确实是英文的，但它的句式非常固定，看多了就知道它在说什么，第三章会专门讲怎么读。

至于数学，入门部分只用到加减乘除和取余，初中水平完全够。不需要提前学什么算法、数据结构，也不需要先精通命令行。如果这三样里你有一样不太行，比如英文报错看着头疼，也不用先去补英语，跟着例子敲一遍，把常见的几种报错认熟，比背单词管用得多。入门这件事，卡住人的从来不是智力，是没人告诉你第一步该点哪里。

3. 第一个例子怎么跑：四步写出 Hello World

3.1 第一步不是背语法，是装一个顺手的集成开发环境

新手最容易在哪儿卡住？不是写不出代码，是代码写完了不知道怎么运行。所以第一步是装工具。你需要的是一个集成开发环境，英文缩写 IDE，说白了就是把编辑器、编译器、调试器打包在一个窗口里的软件：你在上面写，它在下面帮你翻译成机器能执行的东西，出错了还会指给你看是哪一行。

讲义里用的是 Visual Studio，你也可以换成任何一款主流的 C++ IDE，思路完全一样。为什么不建议新手一开始就用「记事本 + 命令行编译」？因为那意味着你要自己配环境变量、自己敲编译命令、自己处理路径里的空格，随便一个环节出错，报错信息都跟 C++ 本身没关系，纯属环境配置问题。新手最怕的就是这种和编程无关的挫败感。先用 IDE 把第一个程序跑通，建立信心，等以后有需要了再回头理解编译过程，顺序不能反。

提示：安装时如果安装器问你要装哪些组件，勾选带「C++ 桌面开发」字样的那一项就够了，不用全选，全选会让安装包大出好几个 G。

3.2 四步走：创建项目、创建文件、编写代码、运行程序

讲义把写一个 C++ 程序拆成四个动作，这个拆法看着朴素，但非常实用，因为它对应了 IDE 里的四次点击。下面按顺序走一遍。

第一步，创建项目。打开 IDE，新建一个项目，类型选「控制台应用」或「空项目」。项目你可以理解成一个文件夹，它会把你的代码文件、配置、编译产物都装在一起，方便管理。

第二步，创建文件。在项目左侧的「源文件」上右键，选择「添加」再选「新建项」，给它起个名字，比如main.cpp。注意后缀必须是.cpp，这是 C++ 源文件的标志，写成.c编译器会用 C 的规则来处理。

第三步，编写代码。把文件建好后，在里面敲下第一段代码。

第四步，运行程序。点工具栏上那个绿色的三角，或者按快捷键（通常是 F5 或 Ctrl+F5）。如果一切正常，会弹出一个黑色窗口，里面有一行字。

// 第一个 C++ 程序：在屏幕上输出一行文字 #include <iostream> // 引入输入输出流库，cout 就在里面 using namespace std; // 使用标准命名空间，省去每次都写 std:: int main() { // 主函数，程序从这里开始执行 cout << "Hello world" << endl; // 把字符串送到屏幕上，endl 表示换行 system("pause"); // 让窗口停住，等你按任意键再关闭 return 0; // 返回 0，告诉系统程序正常结束 }

这段代码的逻辑是：main是整个程序的入口，操作系统启动程序后第一件事就是找它，找不到就报错。cout负责往外送数据，两个小于号像箭头一样指向屏幕方向，endl除了换行还会把缓冲区里的内容立刻推出去。system("pause")是 Windows 下的一个小技巧，不加的话程序跑完窗口会瞬间关掉，你根本看不清输出了什么。

注意：system("pause")只适合本地练习时用，正式项目里不要写，它有平台限制，也不优雅。但在你还分不清「程序崩了」和「程序跑完了」的阶段，留着它，能省掉很多「我是不是写错了」的自我怀疑。

3.3 把 Hello World 拆到每一行，别留黑匣子

很多教程贴完这段代码就过去了，新手照着敲一遍，屏幕上出现 Hello world，然后呢？然后就不知道刚才发生了什么。所以逐行拆一遍。

#include <iostream>是一个预处理指令，意思是「把输入输出相关的工具提前装进这个文件」。iostream这个名字是 input/output stream 的缩写，没有它，编译器不认识cout是谁，会直接报「未声明的标识符」。

using namespace std;解决的是名字前缀问题。标准库里的东西都住在一个叫std的命名空间里，完整写法是std::cout，每次都要加std::太啰嗦，这一行等于告诉编译器「后面看到 cout，默认去 std 里找」。代价是如果别的地方也有同名的东西，可能产生冲突，所以正式项目里通常不这么写，但入门阶段这样写完全没问题。

int main()里的int表示这个函数最后要返回一个整数。花括号{ }圈起来的部分是函数体，也就是真正要执行的语句。return 0;就是那个返回的整数，0 是一个约定俗成的暗号，代表「我正常干完了」。如果你返回别的数，运行程序的系统会认为出了异常。

cout << "Hello world" << endl;这一行可以连着写很多个箭头，意思是「把后面这个东西依次送到屏幕」。字符串必须用英文双引号包住，这是它的身份证，告诉编译器「这是一段文字，不是变量名」。最后的分号是语句的句号，C++ 里每条语句都必须有，漏了是新手最高频的报错之一。

3.4 报错不可怕：三种最常见的编译错误怎么读

先说清楚一件事：编译错误不等于你笨，它只是编译器在说「你给我的东西我看不懂」。而且它说话很有规律，看多了就能一眼定位。

第一种，error C2143: 语法错误: 缺少“;”。这基本就是某一行末尾忘了分号，或者把英文分号打成了中文分号。第二种，error C2065: “cout”: 未声明的标识符。通常是忘了写#include <iostream>，或者using namespace std;拼错了。第三种，fatal error C1083: 无法打开包括文件。这是环境问题，多半是项目类型选错了或者组件没装全，跟你的代码没关系。

遇到报错，第一件事是看它给的行号，直接跳到那一行；第二件事是从上往下看第一个错误，因为一个错误常常引发后面一串连锁报错，后面的可以先忽略。这个习惯我建议你从第一天就养成，否则很容易对着一堆报错乱改，越改越乱。

3.5 注释：现在觉得没用，以后会当成后悔药

注释是写给人看的，编译器在编译时会把它整个忽略掉。C++ 有两种写法：//是单行注释，通常放在一行代码的上方或者末尾；/* ... */是多行注释，用来对一整段代码做整体说明。

// 单行注释：下面这行算的是一周的分钟数 int minutes = 7 * 24 * 60; /* 多行注释： 这段代码用来演示常量定义 常量一旦定义，后面就不能再改 */ const int month = 12;

新手常觉得注释是浪费时间，代码都写出来了还解释什么。但真实的开发场景是：三个月后你回头看自己写的代码，会像在看陌生人写的东西。那时候一行// 这里除以 1000 是把毫秒转成秒能救你半小时。入门阶段不用强求注释写得多漂亮，先做到「关键的那一行，写一句人话」。

4. 变量、常量与数据类型：给每份数据找对收纳盒

4.1 变量：给一块内存起个名字

程序要处理数据，数据得有地方放，变量就是那块地方的名字。语法是数据类型 变量名 = 初始值;，三部分缺一不可。为什么必须指定类型？因为不同类型占的空间不一样，编译器得先知道给你留多大的位置，才能安排内存。

#include <iostream> using namespace std; int main() { // 数据类型 变量名 = 初始值; int a = 10; // 申请一块能装整数的空间，命名为 a，里面放 10 cout << "a = " << a << endl; // 输出：a = 10 a = 20; // 变量可以改，把 20 装进去，10 就被覆盖了 cout << "a = " << a << endl; // 输出：a = 20 system("pause"); return 0; }

这里有个新手容易忽略的点：变量一定要给初始值。有些语言不初始化会给你一个默认的 0，C++ 不会，局部变量不初始化，里面是什么完全看运气，这叫「未定义行为」。它可能跑出个 0，也可能跑出个 32767，还可能这次对下次错，排查起来极其折磨人。所以从第一天起就养成习惯：定义变量的时候顺手把初始值写上，哪怕写个 0。

变量名也不是随便起的。C++ 规定，名字只能由字母、数字、下划线组成，第一个字符必须是字母或下划线，不能是数字；名字区分大小写，age和Age是两个完全不同的变量；还不能用语言预留的关键字，比如int、return、class这些。除了硬性规则，还有一条软性建议：起名要见名知意，studentCount比a1好，totalPrice比x好。这条建议现在看着像废话，等你写到一个两百行的程序里全是 a、b、c、d 的时候，就明白它有多重要了。

4.2 常量：写死就不许改的数

有些数据天生不该被改，比如一周七天、一年十二个月。这类东西用常量存，C++ 有两种写法。

#include <iostream> using namespace std; #define DAY 7 // 宏常量，通常在文件最上方定义，没有分号 int main() { cout << "一周有 " << DAY << " 天" << endl; // DAY = 8; // 放开这行会报错，宏常量不能被赋值 const int month = 12; // const 修饰的常量，定义时就必须给值 cout << "一年有 " << month << " 个月" << endl; // month = 24; // 同样报错，const 变量只读 system("pause"); return 0; }

两种写法都能用，但入门阶段我更建议你用const。原因是#define是预处理阶段的文本替换，编译器根本不知道有这么个常量存在，出了错报错信息会指向奇怪的地方，像隔着一层黑匣子。而const int month = 12;是一个真正的变量，有类型、有作用域，编译器能帮你检查类型对不对，调试的时候也能看到它的值。

顺带说一个容易踩的细节：#define那行末尾不要加分号。因为它是文本替换，你写了分号，替换进去的时候分号会跟着一起进去，本来没问题的语句就可能变成两句，报出一堆莫名其妙的错。

4.3 整型家族和 sizeof：一个字节到底能装多少

C++ 的整数不是一个类型，是一串：short、int、long、long long。它们的区别只有一个，占多大空间、能装多大的数。

long这一行值得单独说一句：它在不同系统上宽度不一样，这是历史遗留问题。所以跨平台的项目里，需要确定宽度时一般不用long，而是用固定宽度的类型。入门阶段你只要记住一个结论就行：日常计数用int，明显会超过 21 亿的数用long long。

想知道某个类型到底占几个字节，用sizeof关键字查，别靠背。

#include <iostream> using namespace std; int main() { // sizeof 可以查类型，也可以查变量 cout << "short 占 " << sizeof(short) << " 字节" << endl; cout << "int 占 " << sizeof(int) << " 字节" << endl; cout << "long 占 " << sizeof(long) << " 字节" << endl; cout << "long long 占 " << sizeof(long long) << " 字节" << endl; int a = 10; cout << "变量 a 占 " << sizeof(a) << " 字节" << endl; // 变量也可以查 system("pause"); return 0; }

sizeof的结果单位是字节，1 字节等于 8 位。它是在编译阶段就确定的值，不会影响程序运行效率。养成用sizeof验证的习惯，比背表格靠谱，因为同一份代码在不同编译器、不同平台上跑出来的结果可能真的不一样。

4.4 浮点、字符、字符串、布尔：四种最容易搞混的类型

小数用浮点型，分float和double。float占 4 字节，大约 7 位有效数字；double占 8 字节，大约 15 到 16 位。

float f1 = 3.14f; // 末尾的 f 不能省，否则 3.14 默认被当成 double double d1 = 3.14; float f2 = 3e2; // 科学计数法，等于 3 乘以 10 的 2 次方，也就是 300 float f3 = 3e-2; // 等于 0.03

那个f后缀是新手高频翻车点。写float f = 3.14;时，编译器会把 3.14 当成double，再往float里塞，属于精度收窄，有些编译器会警告，有些直接报错。加上f就没这事了。

字符型用char，只占 1 个字节，而且只装得下一个字符。写法必须用单引号：char ch = 'a';。用双引号会变成字符串，编译器会告诉你类型不匹配。字符串则是另一回事，string str = "hello world";用的是双引号，而且需要额外引入头文件#include <string>。

#include <iostream> #include <string> // 用 string 必须加这一行 using namespace std; int main() { char ch = 'a'; cout << ch << endl; // 输出 a cout << (int)ch << endl; // 输出 97，字符 a 对应的 ASCII 码 ch = 98; // 也可以直接用编码赋值 cout << ch << endl; // 输出 b string str = "hello world"; // C++ 风格字符串，可以含空格 cout << str << endl; system("pause"); return 0; }

(int)ch这个写法叫强制类型转换，意思是「把 ch 里的内容按整数解释一遍」。字符在内存里存的其实不是字母本身，而是它对应的 ASCII 编码，a是 97，A是 65，所以大小写字母之间差了 32。理解这一点，以后做「大写转小写」这类操作就不会觉得神奇了。

布尔类型bool只有两个值：true和false，占 1 个字节。输出的时候会变成 1 和 0，因为它在底层就是一个整数。bool现在看着没用，但下一章讲比较运算符和条件判断的时候，它就是主角。

4.5 cin：让程序从「自说自话」变成「能听你说话」

前面所有例子都是程序单方面输出，cin让它能接收键盘输入。语法是cin >> 变量;，箭头方向和cout相反，指向变量，表示「把读到的内容送进这个变量里」。

#include <iostream> #include <string> using namespace std; int main() { int age = 0; cout << "请输入你的年龄：" << endl; cin >> age; // 程序会停在这里，等你敲数字再回车 cout << "你输入的是 " << age << endl; string name; cout << "请输入你的名字：" << endl; cin >> name; // 注意：遇到空格就停 cout << "你好，" << name << endl; system("pause"); return 0; }

cin有一个必须知道的脾气：读字符串时遇到空格就停。你输入zhang san，它只会把zhang存进去，后面的san留在缓冲区里，可能影响下一次读取。要读整行带空格的内容，得用getline(cin, name)。这个坑非常经典，几乎每个人都会踩一次，第五章还会再提。

还有一个细节：cin >> age里 age 定义时给了初始值 0，这不是必须的，但建议保留。因为如果输入失败，比如你让人家输年龄，人家敲了个字母，cin会进入失败状态，age 保持原值不变。有初始值，你至少能看出「它没读到新东西」。

5. 新手避坑清单：这五个坑我当年全踩过

5.1 坑一：程序一闪而过，什么都没看清

现象：点运行，黑窗口闪一下就没了，代码明明没报错。

原因：程序执行完return 0;就正常退出了，窗口自然关闭。这不是 bug，是它的正常行为，只是太快了你看不见。

解决：在return 0;前面加一行system("pause");，或者直接用 IDE 的「开始执行不调试」模式运行，那样窗口会自己停住。另外提醒一句，如果你加了system("pause")还是闪退，那多半是编译根本没通过，你运行的是上一次的旧程序，去看「输出」窗口里有没有红色报错。

5.2 坑二：报了一堆错，但代码看着完全没问题

现象：明明照着例子敲的，编译器报error C2018: 未知字符“0xa3”或者一堆看不懂的符号错误。

原因：中文标点。中文的分号「；」、中文的引号「”」、中文的括号「（）」，在编译器眼里都是非法字符，它们长得像英文符号，但编码完全不同。

解决：把输入法切到英文再敲代码里的所有符号。判断方法很简单：英文分号细长，中文分号带点弯曲；英文引号是直的，中文引号是弯的。这个坑几乎人人踩过，踩过一次之后就长记性了。

5.3 坑三：整数除法算出来的结果不对劲

现象：10 / 3算出来是 3，不是 3.333；或者10 / 4 * 4算出来是 8 不是 10。

原因：两个整数相除，C++ 会直接丢掉小数部分，这叫整数除法。而且除法优先级和乘法一样，从左往右算，所以10 / 4先得 2，再乘 4 得 8。

解决：想要小数结果，至少让其中一个操作数变成浮点数，写成10.0 / 3。另外除数为 0 会直接让程序崩掉，写除法前先确认除数不为零。取模运算%也有同样的限制，只能用于整数，小数取模编译器会直接拒绝。

5.4 坑四：变量没初始化，程序时对时错

现象：程序有时候输出正常，有时候输出一个莫名其妙的巨大数字，改都不改，重跑一次结果又变了。

原因：局部变量不初始化，它的值是内存里残留的随机数据，这块内存上次被谁用过、留下什么，你完全无法预测。

解决：定义变量时一律给初始值，int sum = 0;比int sum;安全得多。这个习惯值得从第一天坚持到最后一天，因为这类问题最难排查，它不报错，只是默默地给你错的结果。

5.5 坑五：头文件漏了，或者 cin 读字符串只读到一半

现象一：用了string但没写#include <string>，报「未定义标识符 string」。现象二：输入li si，程序只认了li。

原因：string不属于语言内置类型，它是标准库提供的，必须引入对应头文件。而cin >>读取时以空白字符（空格、制表符、换行）为分隔符，遇到空格就认为这个数据结束了。

解决：第一个问题，把用到的库都在文件顶部引一遍，iostream管输入输出，string管字符串，养成习惯。第二个问题，要读整行就用getline(cin, name);。还有一个连带问题：如果你先cin >> age再getline，缓冲区里剩下的那个回车会被getline读走，导致它直接返回空串，中间加一句cin.ignore();清一下就好。

6. 下一步学什么：把讲义翻到「核心」和「提高」那两章

入门部分跑通之后，最容易出的问题是「接下来学什么」没方向，东看一篇西看一篇，半个月后还在原地。按这份讲义的编排走，路径其实很清楚。

运算符是入门部分最后一块拼图，也是后面所有逻辑的基础。++和--放在变量前后的区别，是新手最爱翻车的地方之一，讲义里那几行例子值得你亲手敲一遍，别只看。

#include <iostream> using namespace std; int main() { int a = 10; int b = ++a * 10; // 前置：先把 a 加到 11，再乘 10，b 是 110 cout << "b = " << b << "，a = " << a << endl; a = 10; int c = a++ * 10; // 后置：先用 10 参与运算，再把 a 加到 11 cout << "c = " << c << "，a = " << a << endl; // c 是 100，a 是 11 system("pause"); return 0; }

前置递增是「先加再用」，后置递增是「先用再加」。记住这一句，再看代码就不会晕。至于&&、||、!这三个逻辑运算符，等你开始写if判断的时候自然会用上，现在知道它们分别对应「并且」「或者」「取反」就够了。

说说我自己的血泪经验。我刚开始学的时候，特别爱「看」代码，一天能刷十几页讲义，感觉全看懂了，一合上书手放在键盘上，连#include后面该写什么都要想三秒。后来改了个笨办法：每看完一个小节，就把书合上，从头到尾手敲一遍，敲不出来就回去看，看懂了再敲。那段时间进度慢得让人焦虑，但两周后我发现，之前反复卡住的东西不再卡了。

从那以后我每次学新东西，都强制自己走一遍「合上书手敲」这个流程，哪怕只是改改变量名、换换初始值，也要让它在我手里真的跑出结果。看会了和写会了，中间隔着的不是理解，是肌肉记忆。你现在看到这份讲义，别急着往下翻，先把第三章那段 Hello world 敲出来，把屏幕上的字改掉，看看窗口里输出的是不是你改的那一句。

希望帮到你。

本文还有配套的精品资源，点击获取