C++ 基础实战：从循环控制到算法入门

while 循环

while 循环本质逻辑与 for 循环类似，适用于条件不确定次数的场景。while(true) 常用于死循环监听，但需注意退出条件。

while (true) {
    // 每次循环判断此条件是否成立，成立即继续运行
    // 实际开发中需配合 break 使用
}

函数与模块化编程

将功能封装成函数可以提高代码复用性和可读性。主函数里的变量通常只能在主函数内使用，而全局变量则可在整个文件访问。

#include <iostream>
using namespace std;

long long a[55]; // 全局变量，全局都可以使用

long long fbnq(int n) {
    a[1] = 1, a[2] = 1;
    for (int i = 3; i <= n; i++) {
        a[i] = a[i - 1] + a[i - 2];
    }
    return a[n]; // 函数需要返回值
}

int main() {
    int n;
    cin >> n;
    cout << fbnq(n) << endl;
    return 0;
}

函数类型说明

• int：返回值为整型。
• long long：返回值为长整型，适合大数。
• bool：返回布尔值（true/false）。
• void：无返回值，函数内不要有 return 语句（除非仅写 return;）。

多重循环

嵌套循环用于处理多维数据或复杂逻辑。模板如下：

for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        // 这段模板内出现的所有变量名均可替换
    }
}

练习示例：饲料调配 使用三重 for 循环解决线性方程组问题。注意循环层数过多可能导致超时，需评估复杂度。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;

int main() {
    int a, b, c;
    cin >> a >> b >> c;
    int a1, b1, c1; cin >> a1 >> b1 >> c1;
    int a2, b2, c2; cin >> a2 >> b2 >> c2;
    int a3, b3, c3; cin >> a3 >> b3 >> c3;

    for (int i = 0; i < 100; i++) {
        for (int j = 0; j < 100; j++) {
            for (int k = 0; k < 100; k++) {
                if (!i && !j && !k) continue;
                int x = a1 * i + a2 * j + a3 * k;
                int y = b1 * i + b2 * j + b3 * k;
                int z = c1 * i + c2 * j + c3 * k;
                if (x * b == y * a && y * c == b * z && x % a == 0) {
                    cout << i << " " << j << " " << k << " " << x / a << endl;
                    return 0;
                }
            }
        }
    }
    cout << "NONE" << endl;
    return 0;
}

结构体

C++ 中的结构体得到了极大增强，几乎和类一样强大，区别在于默认访问权限为 public。

定义与初始化

#include <iostream>
#include <string>
using namespace std;

struct Student {
    string name;
    int age;
    float score;
};

int main() {
    Student stu1;
    stu1.name = "张三";
    stu1.age = 20;
    stu1.score = 85.5;
    cout << "姓名：" << stu1.name << endl;
    cout << "年龄：" << stu1.age << endl;
    cout << "成绩：" << stu1.score << endl;
    return 0;
}

支持多种初始化方式，如聚合初始化（C++11）：

Student stu1 = {"张三", 20, 85.5};
Student stu4{}; // 默认初始化

成员访问与操作

struct Point {
    int x, y;
    void display() {
        cout << "Point(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    Point p1 = {3, 4};
    p1.display();
    Point* ptr = &p1;
    ptr->x = 5;
    return 0;
}

结构体嵌套与动态内存

结构体可以包含其他结构体，甚至指针实现链表。

struct Node {
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

int main() {
    Node* head = new Node(1);
    head->next = new Node(2);
    // 遍历并释放内存...
    return 0;
}

字符串与 ASCII

ASCII 码是字符的数字表示。字符 A-Z 连续，a-z 连续，但大小写之间不连续。

#include <iostream>
using namespace std;

int main() {
    char s = 'A';
    int a = s; // 转换为数字
    cout << a << endl; // 输出 65
    return 0;
}

C++ 的 string 类型支持下标访问，但不支持负索引。

练习示例：史莱姆融合 相邻相同颜色的史莱姆会融合，求最后剩余数量。

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    string s;
    cin >> s;
    int count = 1;
    for (int i = 1; i < n; i++) {
        if (s[i] != s[i - 1]) {
            count++;
        }
    }
    cout << count << endl;
    return 0;
}

递归与回溯

递归是函数直接或间接调用自己的过程。关键在于明确结束条件，避免死循环。

int dg(int n) {
    if (n == 87) return 1; // 结束条件
    return dg(n + 1);       // 引用时 n+1
}

欧几里得算法（辗转相除法）

#include <bits/stdc++.h>
using namespace std;

int gcd(int a, int b) {
    if (a % b == 0) return b;
    else return gcd(b, a % b);
}

int main() {
    int a, b;
    cin >> a >> b;
    cout << gcd(a, b) << endl;
    return 0;
}

回溯法 回溯是一种试错过程，发现不可行路线立即回退。常用于全排列、组合等问题。

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;

bool vis[10];
int plan[10];
int n;

void dfs(int step) {
    if (step == n + 1) {
        for (int i = 1; i <= n; i++) {
            cout << plan[i] << " ";
        }
        cout << endl;
        return;
    }
    for (int i = 1; i <= n; i++) {
        if (vis[i]) continue;
        plan[step] = i;
        vis[i] = 1;
        dfs(step + 1);
        vis[i] = 0; // 回溯
    }
}

int main() {
    cin >> n;
    dfs(1);
    return 0;
}

高精度算法

当数值超过标准类型范围时，需模拟竖式计算。采用逆序存储可避免前导零问题。

void add(string s, int a[]) {
    a[0] = s.size();
    for (int i = 1; i <= a[0]; i++)
        a[i] = s[a[0] - i] - '0';
}