企业官网建设流程全解析

简介：C++入门、核心与提高讲义笔记以单份PDF呈现，面向零基础自学者、在校学生及需要系统梳理知识体系的开发者，帮助读者从第一个程序起步，逐步过渡到面向对象与泛型编程。内容按学习梯度展开：入门部分涵盖Visual Studio项目创建、Hello World、注释、变量与常量、关键字、标识符命名及整型、浮点型、字符型、sizeof等基础类型；核心与提高部分延伸至指针、数组、结构体、类、运算符重载、模板和异常处理，知识链条较完整。资源包共1个PDF文件，约5.07MB，单文件便于通读、检索和离线查阅，适合作为课程配套笔记或复习提纲。已有25997人学习下载，读者可据此建立章节框架，结合示例代码理解语法规则，并针对易错点回顾，为算法、设计模式与项目实践打基础。

1. 先弄明白一件事：C++ 到底能拿来干什么，零基础该不该从它起步

刚打开一份 C++ 入门讲义笔记，满屏的#include、int、cout扑面而来，很多人的第一反应是——这玩意儿我真能学会吗？先把答案放在前面：能。C++ 是一门资历很老的编程语言，特点是跑得快、能直接管理内存，很多对性能挑剔的软件底层都用它写。但它对新手确实不算温柔，语法细节多，稍不注意就编译报错。

这份讲义笔记的价值，不在于让你一次背完所有语法，而在于把「入门」这一段拆成能踩着走的台阶：先跑通一个程序，再认识变量、常量、数据类型，然后让数据参与计算，最后知道自己接下来该学什么。这篇就按这条线带一遍，写给完全没碰过代码、想找一份能照着敲的 C++ 入门材料的人。不需要数学基础，不需要提前学过别的语言，有一台能装软件的电脑就够了。

2. 跑通第一个程序：从新建项目到屏幕上打出 Hello world

学编程最怕的就是「看懂了但跑不起来」。所以这一章不铺垫理论，直接带你把第一个程序跑出来。跑通之后你会发现，编程这件事的入口比想象中矮。

2.1 先准备一个能写、能编译、能运行的地方

写 C++ 不是打开记事本敲字就完事，你还需要一个把代码翻译成机器能执行的东西，也就是编译器。为了不让新手在这上面卡住，通常会用集成开发环境（IDE），它把编辑器、编译器、调试器打包在一个窗口里，省得你来回折腾命令行。这份讲义里用的是 Visual Studio，你在里面新建项目、写代码、点运行，一条龙走完。

打个比方，IDE 就像厨房里那种带案板、灶台、水槽的一体化操作台，切菜、下锅、洗锅都在一个台面上完成。你不用关心燃气管道怎么接，只要专心把菜做好。入门阶段，选一个顺手的 IDE 比研究编译原理重要一百倍。

提示：安装时如果看到一堆可选组件，勾选和 C++ 桌面开发相关的那一组就行，不必全选，装完体积会小很多。

2.2 四步走：新建、加文件、写代码、按运行

讲义把写一个 C++ 程序拆成四步：创建项目、创建文件、编写代码、运行程序。听起来像废话，但这四步的顺序新手特别容易搞混，比如在项目外面新建了一个文本文件，然后发现怎么都编译不了。

1. 打开 IDE，新建一个项目，类型选空项目或者控制台应用。
2. 在右侧的「源文件」上点右键，选择「添加」再选「新建项」，给文件起个名字，比如main.cpp，然后点添加。扩展名.cpp很关键，它告诉工具这是一份 C++ 源码。
3. 在打开的文件里敲代码。
4. 点工具栏上的运行按钮，或者按调试快捷键，让程序跑起来。

下面就是讲义里那个最经典的第一个程序，照着敲一遍，注意标点都是英文半角，中文标点会让编译器看不懂：

#include<iostream> // 引入输入输出相关的工具箱 using namespace std; // 使用标准命名空间，后面写 cout 就不用加 std:: int main() { // 主函数，程序从这里开始执行 cout << "Hello world" << endl; // 往屏幕上输出一段文字并换行 system("pause"); // 暂停一下，防止窗口一闪就关掉 return 0; // 返回 0，表示程序正常结束 }

敲完点运行，屏幕上出现Hello world，再按任意键窗口才关闭，这就成了。别小看这几行，你已经完整走过了「写源码 → 编译 → 链接 → 执行」这条链路，后面所有复杂程序都是在这个骨架上长出来的。

2.3 逐行拆开看：这七行代码各自在干什么

第一次看到#include<iostream>这种带尖括号的写法，很多人会以为是什么魔法咒语。其实它就是在说：我要用别人已经写好的一套工具，请把它包含进来。iostream这个名字由 input、output、stream 三部分拼起来，负责输入输出，cout能往屏幕上打字，靠的就是它。

using namespace std;是省事的写法。标准库的东西都住在一个叫std的「小区」里，正常访问要写全名std::cout。加上这一行等于告诉编译器：我接下来提到的名字，优先去std这个小区里找。入门阶段这么写没问题，等你以后进大项目，会看到很多代码刻意不写这一行，那是为了避免命名冲突，现在不用纠结。

int main()是程序的入口。操作系统启动你的程序，第一件事就是找这个叫main的函数。前面的int表示它会返回一个整数，最后那句return 0;就是把这个 0 交回去，约定俗成代表「一切正常」。cout负责输出，<<可以理解成一个箭头，把右边的内容送进输出流，endl除了换行还会顺带把缓冲区的内容刷出去。

system("pause")这一句不是 C++ 语法的一部分，它是在调用系统命令让窗口停住。很多人第一次运行没写这句，看到黑窗口闪一下就没了，还以为程序崩了。加上它，你才有机会看清输出结果。

2.4 注释：写在代码里的便条，编译器会直接跳过

代码是给机器执行的，但也是给人看的，而且看的人很可能是三个月后的你自己。注释就是夹在代码里的说明文字，编译器编译时会整段忽略，写多少都不影响程序运行速度。

C++ 有兩種注释写法。单行注释用两个斜杠开头，从斜杠到这一行结束都算注释；多行注释用/*开头、*/结尾，中间可以跨很多行。前者适合在某一行的上方或者行尾做简短说明，后者适合在一段代码前面做整体交代。

#include<iostream> using namespace std; /* * 下面这个小程序用来演示注释的两种写法 * 多行注释适合放在一段代码的上方 */ int main() { // 单行注释：通常放在一行代码的上方，或者语句末尾 cout << "注释不会影响程序运行" << endl; return 0; }

新手常犯的一个错是把注释写得毫无信息量，比如在int a = 10;上面写「定义变量 a 等于 10」，这等于什么都没说。真正有用的注释解释的是「为什么」而不是「是什么」，比如「这里除以 100 是因为接口返回的单位是分」。写代码的时候顺手留一句，将来能省掉很多翻旧账的时间。

3. 变量与常量：给内存起名字，顺手把关键字和命名规则吃透

程序要干活，就得能记住数据。这一章讲的就是 C++ 里最基础的两类「容器」：能变的变量和不能变的常量，以及给它们起名字时要守的规矩。

3.1 变量：给一块内存贴上名字

内存可以想象成一排带编号的储物柜，每个柜子能放一点数据。变量就是你先给某个柜子贴上一个名字，之后想取东西、换东西，喊名字就行，不用记编号。语法很直白：先写数据类型，再写变量名，等号后面跟上初始值。

#include<iostream> using namespace std; int main() { // 语法：数据类型 变量名 = 初始值 int a = 10; // 声明一个整型变量 a，并放入 10 cout << "a = " << a << endl; a = 20; // 变量可以改，这里把 10 换成 20 cout << "a = " << a << endl; return 0; }

这里的int决定了这个柜子能放什么类型的东西，a是你起的名字，10是放进去的第一个值。第二次给a赋值不需要再写int，因为类型在第一次声明时就定死了，再写一遍反而会被当成重复定义。

讲义里特别强调：创建变量时最好直接给初始值。局部变量如果不初始化，它里面是什么值取决于那块内存之前被谁用过，可能是个莫名其妙的数字。这种错误特别难查，因为程序不报错，只是结果不对。养成「声明即初始化」的习惯，能帮你绕开一大类玄学问题。

3.2 常量：定下来就不许改的数

有些数值天生不该被修改，比如一周七天、一年十二个月。C++ 提供两种定义常量的方式。一种是宏常量，用#define写在文件上方，预处理阶段会把代码里所有出现这个名字的地方直接替换成对应的值。另一种是const修饰的变量，写法和普通变量差不多，只是前面多了个const，之后任何试图修改它的语句都会在编译时报错。

#include<iostream> using namespace std; #define DAY 7 // 宏常量，习惯写在文件上方，后面不加分号 int main() { cout << "一周有 " << DAY << " 天" << endl; const int MONTH = 12; // const 修饰的常量，有明确的数据类型 cout << "一年有 " << MONTH << " 个月" << endl; // DAY = 8; // 放开这行会编译报错，宏常量不能被修改 // MONTH = 24; // 放开这行也会报错，const 常量同样不可改 return 0; }

两者的差别，入门阶段记住一句就够：宏是「文本替换」，没有类型，出了错编译器给出的提示往往莫名其妙；const是有类型的真正常量，编译器能帮你检查。所以日常写代码，优先用const，宏定义留给那些需要在编译期就确定下来、或者要跨多个文件共享的场合。

3.3 关键字：语言自己占着的词，别拿来当名字

C++ 里有一批词是被语言本身征用的，叫关键字，比如int、const、return、for、while、class、new、delete、public、private、void、static、bool、char、double、true、false。这些词有固定含义，你不能拿它们当变量名或者常量名。

这就像你不能给自家孩子取名叫「公安局」，名字本身没错，但会引发混乱。如果你写了int int = 10;，编译器根本没法判断第一个int是类型还是名字，只能直接报错。讲义里把关键字表列了出来，新手不用背，用的时候对照一下，或者在编辑器里看颜色——大多数 IDE 会把关键字高亮成特殊颜色，撞上了很容易发现。

注意：关键字区分大小写。Int和int不是一回事，前者不是关键字，但也不建议你这么起名，容易看花眼。

3.4 标识符命名：四条硬规矩加一条软建议

标识符就是你给变量、常量、函数起的名字。C++ 对名字有硬性规定，违反任何一条都编译不过。

四条之外还有一条软建议，讲义里写得很实在：尽量做到见名知意。int a = 10;和int studentCount = 10;都能跑，但后者你三个月后看一眼就知道在干什么。新手阶段代码量小，觉得无所谓，等到几百行的文件摆在面前，名字起得随便的代价就显出来了。

4. 数据类型与运算符：给数据选对「容器」，再让它参与计算

变量有了名字，还得有类型。类型决定了这个柜子有多大、能装什么、装进去之后能做什么运算。这一章内容多，但每一样都是后面写程序绕不开的地基。

4.1 整型家族：short、int、long、long long 差在哪

存整数有四种常见类型，区别主要在占用的内存大小和能表示的数值范围。占的字节越多，能装的数越大，但也不是越大越好，够用就行。

入门阶段的经验是：默认用int，除非你明确知道数值会超出它的范围。short省的那点内存，在现代机器上基本感觉不到，反而容易溢出。至于long，它的长度在不同环境下不一致，写跨环境代码时容易翻车，所以很多项目干脆直接上long long。讲义给出的结论很清晰：short < int <= long <= long long，这个顺序记下来，选类型时心里就有谱。

4.2 sizeof：不用猜，直接量一下类型有多大

总有人说int是 4 字节，也有人说在某某机器上是 2 字节。与其背结论，不如让程序自己告诉你。sizeof是 C++ 的一个运算符，用来统计某个类型或者变量占用的字节数。

#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; return 0; }

运行结果里long那一行可能会让你意外，它在不同环境下确实不一样。这也顺带说明一个道理：C++ 标准只规定「至少多大」，具体字节数由编译器和平台决定。所以写代码时别把字节数写死，需要判断的时候用sizeof现场量。

4.3 浮点型：float 和 double 的区别就在「有效数字」

存小数用浮点型，分单精度float和双精度double。float占 4 字节，能保证大约 7 位有效数字；double占 8 字节，能保证 15 到 16 位有效数字。所谓有效数字，通俗讲就是从第一个非零数字开始，能可靠表示多少位。

#include<iostream> using namespace std; int main() { float f1 = 3.14f; // 后面的 f 不能省，否则会被当成 double double d1 = 3.14; cout << "f1 = " << f1 << endl; cout << "d1 = " << d1 << endl; cout << "float 大小：" << sizeof(f1) << " 字节" << endl; cout << "double 大小：" << sizeof(d1) << " 字节" << endl; // 科学计数法：3 乘以 10 的 2 次方 float f2 = 3e2; float f3 = 3e-2; // 3 乘以 10 的负 2 次方，也就是 0.03 cout << "f2 = " << f2 << "，f3 = " << f3 << endl; return 0; }

写float时后面那个f是个高频翻车点。不加的话，3.14默认被当成double，赋值时会发生一次隐式转换，某些编译器会给出警告。另外，浮点数天生不精确，0.1 + 0.2未必等于0.3，这是二进制表示的固有问题，不是你的错。入门阶段记住两条：需要高精度就用double，不要拿浮点数做「是否相等」的判断。

4.4 字符型与 ASCII：一个字节装一个字符

char用来存单个字符，占 1 个字节。写法上有个硬性要求：字符必须用单引号包起来，而且引号里只能有一个字符。

#include<iostream> using namespace std; int main() { char ch = 'a'; // 单引号，里面只能有一个字符 cout << ch << endl; cout << "char 大小：" << sizeof(char) << " 字节" << endl; cout << "a 对应的编码：" << (int)ch << endl; // 强转成整数，看看它的编码值 ch = 98; // 也可以直接用编码值赋值 cout << "编码 98 对应：" << ch << endl; return 0; }

字符在内存里并不是把字母本身画进去，而是存了它对应的 ASCII 编码。小写字母a的编码是 97，b是 98，大写A是 65。ASCII 表里 0 到 31 是控制字符，用来干一些不可见的活，比如换行、响铃；32 到 126 是能打印出来的字符，包括数字、字母、标点和空格。你完全不用背这张表，但知道有这回事，以后看到字符和数字互相转换就不会懵。

提示：char ch = "a";用双引号是错的，双引号代表字符串，类型对不上，编译会直接拦下来。

4.5 转义字符：屏幕上打不出来的那些符号

有些字符你没法直接写进代码，比如换行、制表符、引号本身。这时候要用反斜杠开头的转义字符来表示。常见的有下面几个。

#include<iostream> using namespace std; int main() { cout << "第一行\n第二行" << endl; // \n 起到换行的作用 cout << "姓名\t年龄" << endl; // \t 让两列对齐 cout << "反斜杠：\\" << endl; // 想输出一个反斜杠，要写两个 return 0; }

\t在做简单排版时很好用，输出表格一样的效果。\\这种写法新手容易漏，因为反斜杠在 C++ 里是「转义开关」，单独出现会被认为后面还跟着东西。

4.6 字符串与布尔：一串字和一个真假

字符串就是一串字符。C++ 里有两套写法，一套是继承自 C 语言的字符数组，另一套是 C++ 自己的string类型。前者写法是char 变量名[] = "内容";，后者是string 变量名 = "内容";，用后者需要额外引入<string>头文件。

#include<iostream> #include<string> // 用 string 类型必须加这个头文件 using namespace std; int main() { // C 风格字符串：字符数组 char str1[] = "hello world"; cout << str1 << endl; // C++ 风格字符串：更常用，操作起来方便 string str2 = "hello c++"; cout << str2 << endl; // 布尔类型只有两个值 bool flag = true; cout << "flag 的值：" << flag << endl; // 输出 1 flag = false; cout << "flag 的值：" << flag << endl; // 输出 0 cout << "bool 大小：" << sizeof(bool) << " 字节" << endl; return 0; }

布尔类型bool只有真和假两个值，占 1 个字节。打印出来时真显示 1、假显示 0，因为它本质上就是一个很小的整数。新手写代码时建议直接用true和false，别写1和0，可读性差很多。

4.7 cin：让程序从键盘接数据

前面都是程序往外输出，现在反过来，让程序接收你敲进去的内容。负责输入的叫cin，箭头方向跟cout相反，是两个大于号。

#include<iostream> #include<string> using namespace std; int main() { int a = 0; cout << "请输入一个整数：" << endl; cin >> a; // 等待键盘输入，把读到的整数放进 a cout << "你输入的是：" << a << endl; string name; cout << "请输入一个名字：" << endl; cin >> name; cout << "你好，" << name << endl; return 0; }

cin >> 变量的意思是「从标准输入读一个值，存进这个变量」。程序运行到这一行会停下来等你敲键盘，敲完回车才继续。有个细节要留意：cin读字符串时遇到空格就停，你输入「张 三」，它只会拿到「张」。想读一整行带空格的内容，得换别的方法，这个等学到字符串处理时再说。

4.8 四类运算符：算术、赋值、比较、逻辑

数据进来了，接下来要算。C++ 的运算符按用途分四类，先把这四类摸清，日常代码里的表达式基本就够用了。

算术运算符处理加减乘除和取余。加减乘除不用解释，重点在除法和取模上：两个整数相除，结果还是整数，小数部分直接被砍掉，10 / 3得到 3 而不是 3.33；取模%是求余数，只能用于整数，10 % 3得 1。除数和取模的右操作数都不能是 0，写了会直接崩。

#include<iostream> using namespace std; int main() { int a = 10; int b = 3; cout << a + b << endl; // 13 cout << a - b << endl; // 7 cout << a * b << endl; // 30 cout << a / b << endl; // 3，整数相除，小数被舍弃 cout << a % b << endl; // 1，取余 // 递增：前置是先加再用，后置是先用再加 int i = 10; int j = ++i * 10; // i 先变 11，j 得到 110 cout << "i = " << i << "，j = " << j << endl; int m = 10; int n = m++ * 10; // 先用 10 参与计算，m 之后才变 11 cout << "m = " << m << "，n = " << n << endl; return 0; }

赋值运算符除了最基本的=，还有+=、-=、*=、/=、%=这一组简写。a += 2等价于a = a + 2，写起来短，读起来也清楚。比较运算符==、!=、>、<、>=、<=用来比较两个值，结果只有真或假，打印出来就是 1 和 0。逻辑运算符三个：!取反，&&表示并且，||表示或者。&&要求两边都真才为真，||只要有一边真就为真。

最容易出错的是把==写成=。if (a == 1)是比较，if (a = 1)是赋值，后者在 C++ 里语法合法，但行为完全不是你想的那样。这个坑几乎每个新手都踩过一次。

5. 新手最容易翻车的六个坑：C++ 入门排查清单

语法看懂了不等于能跑通。这一章把入门阶段最高频的六个翻车现场摊开讲，每条都按「看到什么现象 → 为什么会这样 → 怎么解决」走一遍。建议先收藏，报错的时候回来对照。

5.1 坑一：黑窗口一闪而过，什么都看不清

现象：点运行，黑色控制台窗口闪了一下就消失了，代码好像根本没执行。

原因：程序执行完最后一行就结束了，窗口随之关闭。如果你没有加暂停语句，或者是从文件夹里直接双击生成的 exe 文件运行，就会看到这个效果。

解决：在return 0;前面加上system("pause");，程序会停在那里等你按任意键。更规范的做法是在 IDE 里用调试模式启动，IDE 默认会在结束时保留窗口。如果加了还是闪，检查一下是不是加在了return后面，那样永远执行不到。

5.2 坑二：变量没给初始值，结果是一串莫名其妙的数字

现象：int a;之后直接cout << a;，输出的不是 0，而是一个很大的、每次运行还可能不一样的值。

原因：局部变量分配到的内存是之前别人用过的，没初始化就相当于直接读残留数据。C++ 不会自动帮你清零，这是为了性能做的取舍。

解决：声明变量时就给初始值，写成int a = 0;。这条习惯要从第一天养成，它不增加多少工作量，却能省掉大量「明明逻辑没错，结果就是不对」的排查时间。

5.3 坑三：两个整数一除，小数部分凭空消失

现象：10 / 3的结果是 3，明明计算器算出来是 3.33。

原因：C++ 里两个整数相除，结果仍然是整数，小数部分被直接截断，不是四舍五入，是直接砍掉。

解决：让参与运算的至少一方是浮点数。可以写成10.0 / 3，或者先把变量定义成double再除。如果本来是两个整数变量，用(double)a / b做一次强制转换即可。注意(double)(a / b)是错的，那会先把整数除法做完再转，小数已经没了。

5.4 坑四：字符用了双引号，或者单引号里塞了多个字符

现象：char ch = "a";编译报错，提示类型不匹配；或者char ch = 'abc';也报错，提示字符常量太长。

原因：单引号表示单个字符，双引号表示字符串，两者类型不同。单引号里也只能放一个字符，多放几个就超出了char的容量。

解决：存单个字符用单引号，char ch = 'a';；存一串字用双引号，同时把类型换成string或者字符数组。这两个符号在键盘上挨着，敲错是家常便饭，报错信息里看到「字符常量」或者「无法从 const char 转换」这类字眼，先检查引号。

5.5 坑五：名字撞上关键字，或者大小写写错

现象：编译器报一堆错，说某某是「未声明的标识符」，但你明明定义了。

原因：要么名字用了关键字，比如int class = 1;；要么大小写不一致，定义的是count，用的是Count。C++ 对大小写极其敏感，Main和main在它眼里是两个完全不同的东西。

解决：起名之前扫一眼关键字表，或者干脆养成习惯，变量名全用小写加下划线，函数名用动词开头。真遇到「未声明」的错误，先把光标放到报错的那个名字上，用编辑器的查找功能全文搜一遍，看拼写是否完全一致。

5.6 坑六：前置 ++ 和后置 ++ 混着用，算出来差一截

现象：int b = ++a * 10;和int b = a++ * 10;，明明只差一个符号，b的结果却不一样。

原因：前置递增是「先把变量加 1，再拿新值参与运算」，后置递增是「先拿原值参与运算，表达式结束后再给变量加 1」。区别只体现在「同时还要用这个变量」的场合，单独写一行a++;时两者完全一样。

解决：如果一个表达式里既要自增又要用这个变量，先把它拆成两行写清楚，别图省事塞在一行里。真要用，就在纸上画一遍执行顺序：前置看新值，后置看旧值。团队协作时代码可读性比省一行更重要。

6. 下一步学什么：从语法练习到指针、类和 STL 的路线图

把前面几章跑通，你已经能写出「定义变量、输入、计算、输出」这种小程序了。接下来最怕的是没有方向，今天看看这个教程，明天翻翻那个视频，两个月过去还在原地。比较稳的走法是一条主线往下推，每一段都配上能跑起来的小练习。

第一阶段把语法练熟。变量、常量、数据类型、运算符这些，光看会忘，必须动手。建议每天写三五个小题目，比如输入两个数输出它们的和与平均值、判断一个年份是不是闰年、把摄氏温度转成华氏温度、用循环打印九九乘法表。题目不难，但能把手感练出来，报错见多了就不慌了。

第二阶段进数组和函数。数组让你一次管理一组同类型数据，函数让你把一段逻辑打包起来重复使用。这两个东西是后面所有内容的地基，指针、类、标准库全都建立在它们之上。练手项目可以做一个学生成绩统计，输入若干分数，算平均分、最高分、最低分，再按从高到低排个序。

第三阶段才是讲义里说的「核心」和「提高」部分：指针、引用、结构体、类、运算符重载、模板、异常处理。指针是 C++ 的分水岭，它让你直接操作内存地址，威力大风险也大；类是面向对象的入口，把数据和操作数据的方法打包在一起。这一段不用急着速通，每个概念都配一个小 demo 消化掉再往前走。

还有一个容易被忽略的点：学会看报错。编译器给出的错误信息往往很长，新手第一反应是全部复制去搜，其实大部分时候看第一行就够了，它通常指向真正的问题所在。养成从第一条错误往下读的习惯，后面的错误很多是第一条引发的连锁反应。

我自己的血泪经验是，每次新建一个项目，都强制先写一个 Hello world 跑通，确认工具链没问题，再开始写当天要练的逻辑。听起来多余，但它把「环境问题」和「代码问题」彻底分开了，排查的时候能少走一大半弯路。从那以后我每次碰新环境都这么走一遍，再没出现过写了半小时代码发现根本编译不了的情况。希望帮到你。

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