C++入门这个系列写到第二篇，该碰点真正决定“程序好不好写”的东西了。上一篇把变量、类型、运算符这些地基过了一遍之后，很多初学者会卡在一个很尴尬的位置：语法都认识，但一看题目还是不知道从哪里下手，写出来的代码要么绕来绕去，要么编译报错看半天也不知道错在哪。
这篇我打算把控制结构、函数、数组和指针这些“骨架”性质的内容一次性串起来讲。不是照着教科书念定义，而是按我平时写代码、带新人时真正会关注的顺序来：先解决“怎么让程序按我的想法走”，再解决“怎么把逻辑组织得不那么乱”，最后聊聊数组和指针这两个最容易劝退新手的难点到底在难什么。看完这篇，你至少应该能独立写出带分支、带循环、带函数调用的完整小程序，而不是停留在“只能跑通示例代码”的阶段。
2. 条件与分支：让程序学会看人下菜碟
程序和人最大的区别在于，人看到红灯会停、绿灯会走，程序默认只会从上到下把每一行都执行一遍。想让程序“懂事”，第一个要掌握的就是分支结构。它也是后面所有复杂逻辑的基础，这一块如果没吃透，后面写循环、写递归都会觉得别扭。
2.1 if-else的三种姿势，以及最常见的缩进陷阱
C++里最简单的分支就是if，但“会用”和“用得对”之间隔着一个很关键的习惯问题。先看三种基础写法：
// 姿势一：单分支 if (score >= 60) { cout << "及格了" << endl; } // 姿势二：双分支 if (score >= 60) { cout << "及格了" << endl; } else { cout << "要补考了" << endl; } // 姿势三：多分支 if (score >= 90) { cout << "优秀" << endl; } else if (score >= 80) { cout << "良好" << endl; } else if (score >= 60) { cout << "及格" << endl; } else { cout << "不及格" << endl; }第二种和第三种看着简单，但新手极容易踩一个坑：else的配对问题。C++里else会跟最近的那个尚未配对的if结合，跟缩进无关。下面这段代码就是典型的反面教材：
if (a > 0) if (b > 0) cout << "a和b都大于0" << endl; else cout << "a不大于0" << endl; // 这个else实际配对的不是第一个if！从缩进上看，写代码的人想让else跟第一个if配对，但编译器不认缩进，它只认语法结构。实际运行时，这个else配的是第二个if，也就是说只有当a > 0且b <= 0时才会输出“a不大于0”，逻辑完全反了。
解决办法有两个：要么把第二个if用花括号包起来，做到“无歧义”：
if (a > 0) { if (b > 0) { cout << "a和b都大于0" << endl; } } else { cout << "a不大于0" << endl; }要么干脆把else那行的缩进对齐到第二个if下面，虽然代码意思变成了“a大于0但b不大于0”，但至少不会出现“你以为对、实际不对”的灵异情况。我的习惯是：不管多少层，一律写花括号。哪怕里面只有一行代码，也包上。这事看着多余，但能帮你省掉无数个debug到凌晨的夜晚。
2.2 switch-case的核心规则：别让case悄悄“穿透”
当你要判断的值是某个固定的整数或字符时，switch-case往往比一连串的else-if更清晰。但它的语法规则比if要复杂一点，最典型的就是case穿透：
int day = 3; switch (day) { case 1: cout << "星期一" << endl; break; case 2: cout << "星期二" << endl; break; case 3: cout << "星期三" << endl; break; default: cout << "未知" << endl; }如果不写break，比如case 2后面没有break，那么当day等于2时，程序会连着执行case 3的内容，直到遇到break或者switch结束。这在某些场景下是刻意利用的（比如你想让多个case共用同一段逻辑），但对刚入门的人来说，先老老实实写break，等你能明确说出“我故意不写break是为了让多个case合并执行”时，再考虑优化。
switch还有一个容易忽略的点：case后面的值必须是整型或枚举类型，不能是浮点数、字符串。如果你尝试switch (str)然后case "abc":，编译器会直接报错。想对字符串做多路判断，老老实实写if-else链，或者学完后续的map容器再回来优雅处理。
2.3 布尔运算和短路求值：程序效率的一个隐蔽来源
分支里天天要写条件表达式，而条件表达式里最常用的就是关系运算符和逻辑运算符。其中&&（逻辑与）和||（逻辑或）有一个非常重要的性质——短路求值。
简单说，A && B如果A已经是false，那不管B是真是假，整个表达式一定是false，B根本不会被计算；A || B如果A已经是true，那B也不会被计算。这个特性不只是性能优化，更是很多代码能“正常工作”的前提：
if (b != 0 && a / b > 2) { // ... }如果b等于0，b != 0直接为false，a / b根本不会执行，于是避免了除零错误。如果把顺序反过来写成if (a / b > 2 && b != 0)，b为0时程序直接在第一个条件的除零运算上崩溃了。这就是为什么我总提醒新手：把“安全检查”写在短路的左边。
另外提一个很多人会犯的错：判断相等要用==，不是=。if (x = 0)在C++里是合法的，它的含义是把0赋给x，然后拿x的值（也就是0）做判断，0转成bool是false，程序不会报错但逻辑全错。不少老手也被这个坑过，我的建议是写if (0 == x)这种“常量放左边”的写法，万一你少打一个等号，编译器会因为0 = x是非法赋值直接报错，等于在编译期就帮你抓出bug。
3. 循环：让程序学会反复“折腾”
说完了“看人下菜碟”，接下来是“一件事反复干”。循环是计算机最擅长的事——人类重复十次就会烦躁，程序重复十万次眼睛都不眨一下。C++里有三种循环：while、do-while和for，它们各自有适合的场景，用完一种就换另一种没有意义，关键是搞清楚每种循环的“性格”。
3.1 for循环的三个表达式，执行顺序别搞混
for循环是初学者第一个容易犯迷糊的地方：
for (int i = 0; i < 10; i++) { // 循环体 }括号里三部分别是：初始化表达式、条件表达式、循环后表达式。它们不是一次性一起执行的，完整的执行流程是：先执行一次初始化（int i = 0），然后检查条件（i < 10），成立则进入循环体，结束后执行i++，然后再检查条件……如此反复。
很多人把“循环后表达式”理解成“循环体里的最后一行”，其实不太准确。它的执行时机是在每次迭代结束、下一次条件判断之前。拿累加求和来说：
int sum = 0; for (int i = 1; i <= 100; i++) { sum += i; }i从1开始，每次加1，当i变成101时条件101 <= 100为假，循环结束。最终sum等于5050。如果面试官问你这段代码循环体执行了多少次，答案是100次，不是101次，别数错。
有个小技巧想分享给新手：for循环的变量i不建议在循环体里手动改，比如i += 2之类，这样会让循环次数变得极难追踪。想跳着遍历，直接在i++那里写i += 2，让循环结构自己控制步进，你的代码可读性会好一个档次。
3.2 while和do-while：一个“先看后做”，一个“先做再看”
while和for的区别在于，while没有天然的“初始化”和“步进”位置，更适合循环次数事先不知道的场景，比如“持续读取输入直到遇到某个值”：
int n; while (cin >> n) { // 只要输入有效，就持续处理 }do-while则是最容易被忽略的一个，它的特点是至少执行一次循环体，再判断条件。这个特性在某些场景下特别好用，比如“让用户输入一个整数，如果不合法就重新输入”，正常情况下至少要给用户一次输入机会，用do-while最自然：
int choice; do { cout << "请输入一个1-5之间的数字："; cin >> choice; } while (choice < 1 || choice > 5);注意do-while的while后面有个分号，第一次写的朋友十有八九会漏掉，然后编译错误看半天反应不过来。
3.3 break、continue和嵌套循环：如何优雅地“跳出重围”
break是“跳出整个循环”，continue是“跳过本次迭代、直接进入下一次”。二者的区别可以用“撞到枪口”来比喻：break是放弃整个任务直接撤退，continue是绕开这个障碍继续做剩下的。
有些人写循环时特别喜欢用“循环里套if再包一层”，比如想跳过所有偶数：
for (int i = 1; i <= 10; i++) { if (i % 2 == 0) { continue; } cout << i << " "; }这段代码输出的是1 3 5 7 9。continue让程序直接跳到i++，不执行输出。如果你忘了写continue改成了break，那遇到2时整个循环就停了，只会输出一个“1”——两个关键字差个字母，行为天差地别。
嵌套循环里的break尤其容易搞混：break只跳出最内层的一层循环。比如你有一个双层循环想找到特定组合后就全停，只写break是不够的，需要用到标志变量或者把逻辑封装成函数用return返回。这也是为什么我建议新手不要写超过三层的嵌套循环，一旦超过，可读性断崖式下跌，选择把内层逻辑提取成函数变量或者封装成函数，比硬写要明智得多。
4. 函数：把代码“模块化”，本质是管理复杂度
学会了顺序、分支、循环，你已经能写出“能跑”的程序了。但如果你尝试写一个两百行的练习项目，会发现一个尴尬的事实：代码全堆在一起，看着看着就晕了，改一个功能经常带出几个新bug。这时候就该学函数了。
函数的核心作用不是“复用代码”——复用只是它的副产品——真正的核心作用是命名。你把一段逻辑起个名字，比如calcAverage，后面看到这个名字，一眼就知道它在干什么，不用逐行去读那一坨计算公式。这对头脑的“内存释放”极为关键。
4.1 传值 vs 传引用：为什么有些函数“改不动”外部变量
函数参数传递是新手最困惑的部分之一。先看最基础的传值：
void change(int a) { a = 100; } int main() { int x = 10; change(x); cout << x << endl; // 输出10，没变！ return 0; }原因在于，change(x)这句调用发生时，程序把x的值复制了一份给参数a，change函数里改的是副本，跟原来的x毫无关系。这叫做“传值调用”。菜的年份比较多的时候，我在看别人代码时就见过好几个同学在这卡了一下午：为什么函数里改了，外面没变？
解决办法是传引用：
void change(int& a) { a = 100; } int main() { int x = 10; change(x); cout << x << endl; // 输出100 return 0; }int& a的意思是“a是某个int变量的别名”，不复制，直接转发给外部变量。所以函数里对a的任何修改都会直接作用到调用处的x上。这背后的实现原理其实就是个指针（后面会讲），但你现阶段不用管底层细节，只要记住一条经验标准：
如果函数需要修改外部变量的值，传引用；否则就传值。另外，如果参数是个特别大的对象（比如后面学的string、vector），即使你不想修改它，也建议用const 类型& 参数名——这样可以“把东西借来看”，既避免复制开销，又防止误改。
4.2 函数的返回值、默认参数和重载：C++给你的一些“语法糖”
函数返回值的类型写在函数名前面，这是C++跟很多现代语言不一样的地方。别小看这个位置，新手经常搞混int function()和function() int，后者会直接编译失败。
默认参数可以让函数调用时省略部分参数。这个特性的坑在于，默认参数必须从右往左连续设置，不能跳着设：
void printInfo(string name, int age = 18, string city = "某城"); // 可以printInfo("张三")，也可以printInfo("张三", 20)，但不能printInfo("张三", "某城")如果想第一个参数有默认值、但后面没有，编译器会直接报错。它的规则是：调用时你只能从右边开始省略参数，从左往右传参。
函数重载指的是：同名函数，只要参数个数或类型不同，C++会当作不同的函数处理：
int add(int a, int b) { return a + b; } double add(double a, double b) { return a + b; }调用add(1, 2)走第一个，add(1.5, 2.5)走第二个。编译器靠参数类型区分到底调用谁。有一点要注意：返回值不能作为重载的依据，只改返回类型不改参数，编译器会报“重定义”错误。因为调用处可能根本不用返回值，编译器根本没法区分你想调哪一个。
4.3 分文件写代码：尽早养成“头文件+源文件”的分离习惯
很多初学C++的人写函数都在一个main.cpp里写完，这在小练习里没问题，但一旦项目变大，坑就开始出现了。真正的工程化写法是：函数的声明放在头文件（.h）里，定义放在源文件（.cpp）里，各个源文件通过#include头文件来使用函数。
举个最简例子：
// calc.h #ifndef CALC_H #define CALC_H int add(int a, int b); #endif // calc.cpp #include "calc.h" int add(int a, int b) { return a + b; } // main.cpp #include "calc.h" #include <iostream> int main() { std::cout << add(3, 5) << std::endl; return 0; }很多新手不理解为什么声明和定义要分开。声明的作用是“告诉编译器有这么个函数，参数和返回类型是什么”，让编译器在遇到调用时不至于两眼一抹黑；定义才是“实现它”。如果只有定义没有声明，编译器按顺序编译时，在调用处还没见过这个函数，就会报错“标识符未找到”。
头文件里那三行#ifndef / #define / #endif是防重复包含的经典写法，没有它，同一个头文件被多个源文件include时，编译器会疯掉。早年写代码时，我在头文件上踩过不少重复定义的雷，现在习惯是一律加上这个“头文件守卫”。
5. 数组和字符串：连续内存上的“第一课”
说完了流程控制，是时候碰一个很多人口中的“劝退点”——数组。数组本身不复杂，复杂的是它衍生出来的一整套“指针玩法”。但在我个人看来，数组和指针其实是被书上的抽象解释给坑了的——它们没那么吓人，只是你需要理解一点计算机底层的东西，而不是死记语法。
5.1 数组的声明、初始化，以及那个永恒的下标问题
数组的声明也很简单：
int arr[5] = {1, 2, 3, 4, 5};它表示一块连续的内存空间，里面可以存5个int。访问方式是arr[0]到arr[4]——下标从0开始，这是几乎每个新手都会撞一次墙的地方。为什么从0不从一开始？底层原因是数组名实际上是指向首元素的地址，而arr[i]的完整含义是“从首地址往后移动i个元素”。如果下标从1开始，意味着你要先把指针往后退一个位置，这对硬件来说纯属浪费。所以C++选了从0开始，你只能适应。
数组初始化时可以不完全给值，剩下的自动补0：
int arr[5] = {}; // 全0 int arr[5] = {1, 2}; // {1, 2, 0, 0, 0}一个很容易被忽略的坑是数组越界：C++不像某些语言会自动检查下标，你完全可以写arr[5]甚至arr[10]，程序不会立刻报错，它只是读或写了一块不属于这块数组的内存。这就可能导致：数据被悄悄改掉、程序崩溃，或者更恶心的是——安静地错着，完全看不出问题。我记着自己当年刷题时，就因为数组开小了1个元素，查了一下午的“随机崩溃”，其实是个越界写把别的变量覆盖了。所以记住一条保命原则：开数组时多开几个位置，循环时仔细检查边界。
5.2 数组遍历的正确姿势与范围for
遍历数组最常见的是用for循环：
int arr[5] = {10, 20, 30, 40, 50}; for (int i = 0; i < 5; i++) { cout << arr[i] << " "; }但这么写有个隐患：循环条件里的5是写死的，一旦数组大小变了，你还要记得改这里，忘了那就好玩了。更稳的写法有两种。一种是C++11引入的“范围for”：
for (int x : arr) { cout << x << " "; }它不关心数组多大，自动从头遍历到尾。另一个思路是用sizeof：
int n = sizeof(arr) / sizeof(arr[0]); for (int i = 0; i < n; i++) { cout << arr[i] << " "; }sizeof(arr)是整个数组占的字节数，sizeof(arr[0])是单个元素占的字节数，一除就是元素个数。这个方法在函数内部传数组时不好使，因为数组传到函数里会“退化”成指针（后面马上讲），在函数里sizeof(arr)拿到的是指针大小而不是数组大小。这也是为什么我之前强调用范围for，它至少在你还没学会传数组大小的最佳实践之前，能帮你绕开一批莫名其妙的bug。
5.3 C风格字符串 vs string：为什么我更推荐string
C++里字符串有两套打法。一套是C风格字符串，本质是字符数组，以'\0'结尾：
char str[20] = "hello";另一套是C++标准库提供的std::string：
#include <string> string s = "hello";对一个新手来说，我的建议非常明确：能不用C风格字符串就不用。C风格字符串的坑多到数不完：数组大小不够时字符串会被截断、忘记\0结尾时各种函数会越界读取、比较两个字符串要用strcmp而不是==……而string直接把这些痛苦全部封装掉了，支持==比较、支持+拼接、支持直接用size()拿长度，很多教科书用C风格字符串纯粹是历史遗留习惯。
之前在带新人跑一个项目时，有人用C风格字符串存用户输入，忘了给预留终止符，程序一运行结果就“贯穿屏幕”。后来换成string，噩梦当场结束。你现在学string，后面看老代码时再补C风格的知识点，顺序比反过来要顺得多。
6. 指针和引用：把“地址思维”一次讲透
指针是C++阶段真正的分水岭。对很多新手来说，它像一道过不去的坎，但真把它拆开看，它不过就是一句话的事：指针是一个变量，这个变量里面存的是别人地址。就这么简单。
6.1*号和&号的两种身份，千万别混
初学者看到指针就头疼，很大程度上是被*和&这两个符号的“多重身份”搞晕了。先把它俩的身份证分清楚：
*在声明里表示“这个变量是个指针”，在表达式里表示“取出这个指针所指向的那个值”。&在声明里表示“这是一个引用”，在表达式里表示“取地址”。
int x = 10; int* p = &x; // 声明p为指针变量，&x取x的地址 cout << *p; // 输出10，*p取p指向的那个值新手最容易犯的错是把声明当乘法、把取地址当引用搞混。其实规则很简单：看它出现在哪个语境。声明里跟在类型后面，int* p表示p指针的类型是int*；表达式里单独出现，*p就是解引用操作。
6.2 为什么能修改指针指向的内容，却“传不出去”指针本身
回到之前那个“函数改不了外部变量”的问题。你在main里有个int变量x，你担心函数改不到它，于是学了个“传指针”的用法：
void change(int* a) { *a = 100; } int main() { int x = 10; change(&x); cout << x << endl; // 100 return 0; }这里&x把x的地址传给a指针，然后*a = 100直接修改了那个地址上的内存，所以生效了。这里要理解的关键是：指针本身是传值的，是“地址值”被复制了；但通过这个副本地址，你能修改它指向的那块内存。就好比你给朋友一把你家的钥匙——钥匙是复制品，但开的是同一个门。
经常有人问：“既然有了引用，学指针还有什么意义？”答案其实很现实：很多系统编程接口、回调函数、数组与内存操作都跟指针绑死在一起，你没法只靠引用绕开它。引用更像C++为了让你写起来舒服而加的“语法糖”，底层还是地址那点事。所以我建议你：先学明白指针，再回头看引用，保证通体舒畅。
6.3 new和delete：手动管理内存的正确姿势
到C++的“堆”上动态分配内存，新手最容易“泄漏”也最容易“误用”。先看基本姿势：
int* p = new int; // 在堆上申请一块int空间 *p = 50; delete p; // 用完必须释放！ int* arr = new int[10]; // 动态数组 delete[] arr; // 注意释放数组要用delete[]这里的铁律是：new过了就一定要delete，而且delete和delete[]不能混用。如果你new的是数组，释放时写delete arr，在部分编译器上会静默少释放一部分或者直接崩溃，属于典型的环境相关、心累到极致的坑。
另一个经典陷阱是悬空指针：你把一个指针delete了，但没把指针置空，然后又在别处用到它，程序读到的是一块已经还给系统的内存，结果是未定义的——随时可能跑出个随机值或者直接段错误。安全习惯是：
delete p; p = nullptr;C++里nullptr专门用来表示“空指针”，它比C语言时代流传下来的NULL更类型安全，后续新代码一律用nullptr就完事了。
6.4 指针运算：数组名与指针之间“剪不断”的关系
最后把数组名和指针的关系说透，这算是理解C/C++内存世界的一个里程碑。先上一段代码：
int arr[5] = {10, 20, 30, 40, 50}; int* p = arr; // 数组名arr可以直接赋值给指针，它等于&arr[0] cout << *p << endl; // 10 cout << *(p + 2) << endl; // 30，p+2表示向后移动2个int cout << p[2] << endl; // 30，p[2]和*(p+2)完全等价数组名可以理解为“指向首元素的指针常量”，你不能给arr重新赋值（arr = p是错的），但在表达式中它几乎处处等价于指针。p + 2这个表达式的含义不是“地址值加2”，而是“跳过2个int”，编译器会根据指针的类型自动计算偏移量。这种“带类型的地址偏移”体系，就是指针最独特的魅力。
但有一个地方会让新手栽跟头：在函数参数里声明“数组”时，其实会被编译器悄悄改写成指针：
void print(int arr[], int n) { // 这里的arr本质上是int*，sizeof(arr)只会得到指针大小 }这也是每当我看到新手写的“在函数里sizeof数组想求长度”的代码报错时，最常解释的一句话。在这个阶段，想正确传数组并知道长度，最好的做法就两个：一是传指针的同时传长度参数；二是用C++的容器替代原生数组——比如std::vector，它自带size()，完全不用操心这种破事。
7. 调试基本功：学会“看到bug不说话先打日志”？
标题是我常挂在嘴边的一句调侃，但背后是实打实的血泪经验。程序跑不过、跑错、跑出随机值，这是每个初学者每天的日常。如果没有一套系统的排查手段，光靠猜，效率极低。
7.1 观察变量：你是先猜，还是先打印？
无数新手的第一个反应是盯着代码反复看，试图用“瞪眼法”找出bug。但代码面前人人平等，很多时候“瞪眼”看不出问题，你需要的是把程序运行中的中间值暴露出来。
一个非常朴素但好用的手段就是在关键位置打印变量。比如你怀疑循环里有问题，就打印循环变量的值：
for (int i = 0; i < n; i++) { cout << "i=" << i << ", arr[i]=" << arr[i] << endl; // 其他逻辑 }代码量少的时候，这比调试器更直观。经验上，一个int一个vector等打印全不吃亏，你看到的是程序真实状态，而不是你以为的状态。打日志的关键是“带上下文”，别光打一个数字，至少要说明当前是在哪个循环、哪个分支里。
7.2 让代码“说话”的三个小技巧
如果你觉得cout大法太原始，下面三个进阶技巧能帮你更高效地定位问题：
主动检查输入与边界。数组越界、除零、空指针，这三类问题几乎占了初学者bug的七成。写代码时，多问自己一句：“如果这里的输入是0怎么办？如果数组是空怎么办？” 然后在代码里加判断，宁可提前拦掉，也别让错误在十万行之后爆发。
用最小的输入复现。很多新手一上来就用大数据量测试，越出错越多，越错越看不出规律。我的习惯是：先把n调到3或者5，把数组元素固定成1、2、3这种连续小值，让程序逻辑的每一步都可手工验算。等小输入跑对了，再逐步放大，这样能最快收缩bug范围。
把“深埋”逻辑拆成函数。如果你的代码出现了三层以上的嵌套，或者一个循环体里塞了十几个if，那多半不是再找bug，而是该重构了。把一段独立逻辑抽成函数，单独为它造几个测试案例验证，比在一个超长函数里用cout慢慢找要快几个量级。
实际带人的时候，我经常跟初学者讲这么一句话：“你没有调试器也能写程序，但你没有输出你还真不好定位。”先把合理打印的习惯养好，再学着用断点调试器，两条腿走路，进步会快很多。
这一篇的内容说实话密度不低，从分支、循环到函数、数组和指针，几乎是C++程序从“玩具”到“工具”的必经之路。但只要动手把每个例子敲一遍，不求快、不求多，踏踏实实跑通，你一定能在大概一周内感受到“写代码”这件事从“看天书”变成“有章法”的质变。下一篇有机会我会继续往后写更进阶的话题，但眼下，先把手头的代码写好、跑对。
