讨论详情 - Online Judge

C++
C++循环教程
admin SU @ 2024-12-7 21:50:10

C++循环教程

1. 为什么需要循环？

在编程中，我们经常需要重复执行一些操作。例如，计算1到100的整数和，或者输出一个数组中的所有元素。如果没有循环，我们就需要手动写很多重复的代码，这不仅繁琐，而且容易出错。循环结构可以让我们轻松地重复执行一段代码。

2. for循环

基本语法和工作原理
- for循环的基本语法如下：
```
for (初始化表达式; 条件表达式; 更新表达式) {
   // 循环体：要重复执行的代码
}
```
- 初始化表达式：在循环开始前执行一次，通常用于初始化循环变量。例如，int i = 0; 初始化一个整数变量i为0。
- 条件表达式：每次循环开始时都会检查这个条件。只要条件为真（非零），就会执行循环体。例如，i < 10 表示当i小于10时，循环继续。
- 更新表达式：在每次循环体执行完后执行，用于更新循环变量。例如，i++ 会使i的值每次增加1。
示例：计算1到10的整数和
```
int sum = 0;
for (int i = 1; i <= 10; i++) {
   sum += i;
}
std::cout << "1到10的整数和为：" << sum << std::endl;
```
- 在这个例子中，i是循环变量。首先i被初始化为1，然后每次循环检查i <= 10这个条件。如果条件满足，就执行循环体sum += i;（将i的值加到sum上），然后执行i++更新i的值。当i大于10时，循环结束，最后输出总和。

3. while循环

基本语法和工作原理
- while循环的基本语法是：
```
while (条件表达式) {
   // 循环体：要重复执行的代码
}
```
- 只要条件表达式为真（非零），就会一直执行循环体。和for循环不同的是，while循环没有专门的初始化和更新部分，需要在循环体外部初始化循环变量，在循环体内部更新循环变量。
示例：输出1到5的数字
```
int num = 1;
while (num <= 5) {
   std::cout << num << " ";
   num++;
}
std::cout << std::endl;
```
- 这里首先初始化num为1，然后每次循环检查num <= 5这个条件。如果为真，就输出num的值，然后执行num++更新num。当num大于5时，循环结束。

4. do - while循环

基本语法和工作原理
- do - while循环的基本语法如下：
```
do {
   // 循环体：要重复执行的代码
} while (条件表达式);
```
- do - while循环和while循环很相似，但它是先执行一次循环体，然后再检查条件表达式。这意味着循环体至少会执行一次。
示例：猜数字游戏（简单版）
```
int numberToGuess = 7;
int userGuess;
do {
   std::cout << "请猜一个数字（1 - 10）：";
   std::cin >> userGuess;
} while (userGuess!= numberToGuess);
std::cout << "猜对了！" << std::endl;
```
- 在这个例子中，首先会要求用户猜一个数字，然后检查用户猜的数字是否等于要猜的数字（7）。如果不等于，就会再次要求用户猜测，直到猜对为止。因为是do - while循环，所以至少会要求用户猜一次数字。

5. 循环嵌套

概念和用途
- 循环嵌套是指在一个循环内部再放置一个循环。这在处理二维数据结构（如二维数组）或者需要多层重复操作时非常有用。例如，打印一个乘法口诀表。
示例：打印乘法口诀表
```
for (int i = 1; i <= 9; i++) {
   for (int j = 1; j <= i; j++) {
      std::cout << j << "×" << i << "=" << i * j << "\t";
   }
   std::cout << std::endl;
}
```
- 外层的for循环控制行数（从1到9），内层的for循环控制每行的乘法算式个数（每行的算式个数和行数相同）。对于每一行i，内层循环会从1到i，输出乘法算式j × i = i * j，并使用\t（制表符）来使输出格式更整齐。每一行结束后，使用std::cout << std::endl;换行。

admin SU @ 2024-12-7 21:54:31
1. 基于范围的for循环（C++11引入）
  
  功能和语法
  
  基于范围的for循环主要用于遍历容器（如数组、vector、list等）或其他可迭代对象中的元素。它的语法简洁明了，不需要显式地使用索引或迭代器来访问元素。
  
  基本语法是：for (元素类型元素变量 : 可迭代对象) { 循环体 }。例如，遍历一个整数数组：
  int numbers[] = {1, 2, 3, 4, 5}; for (int num : numbers) { std::cout << num << " "; }
  
  在这个例子中，num是在每次循环中从numbers数组中获取的元素，循环会自动遍历数组中的每个元素，将其赋值给num，然后执行循环体。这种方式比传统的for循环通过索引访问数组元素更加简洁直观，特别是在不需要索引值的情况下。
  
  适用场景
  
  当只需要对容器中的元素进行简单的遍历操作，如输出每个元素、对每个元素进行相同的计算等，基于范围的for循环是非常方便的选择。例如，对一个vector容器中的字符串进行拼接：
  #include <iostream> #include <vector> #include <string> int main() { std::vector<std::string> words = {"Hello", " ", "World", "!"}; std::string result; for (std::string word : words) { result += word; } std::cout << result << std::endl; return 0; }
  
  这里通过基于范围的for循环，将words向量中的每个字符串依次拼接起来，得到最终的结果并输出。
2. 递归（可以看作是一种特殊的循环）
  
  概念和原理
  
  递归是指在函数的定义中使用函数自身的方法。一个递归函数通常包含两个部分：基线条件（递归终止条件）和递归调用。当满足基线条件时，递归停止；否则，函数会调用自身，每次调用时参数会向基线条件靠近。
  
  例如，计算阶乘的递归函数：
  int factorial(int n) { if (n == 0) { return 1; } else { return n * factorial(n - 1); } }
  
  在这个函数中，if (n == 0)是基线条件，当n为0时，函数返回1。否则，函数通过return n * factorial(n - 1)进行递归调用，每次调用时n的值减1，直到n等于0。
  
  适用场景
  
  递归在处理具有递归结构的数据或问题时非常有用，如树结构（二叉树的遍历、查找等）、分治法问题（如归并排序、快速排序等）。以二叉树的前序遍历为例：
  struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; void preorderTraversal(TreeNode* root) { if (root == NULL) { return; } std::cout << root->val << " "; preorderTraversal(root->left); preorderTraversal(root->right); }
  
  这个函数用于遍历二叉树的节点。当根节点root为NULL时，递归终止。否则，先输出根节点的值，然后递归地遍历左子树和右子树，按照前序遍历的规则（根 - 左 - 右）访问二叉树中的每个节点。
admin SU @ 2024-12-7 21:53:24
1. for循环适用场景
  
  遍历数组和容器
  
  在C++中，for循环非常适合用于遍历数组和各种容器（如vector、array等）。因为在这种情况下，通常知道数组或容器的大小，for循环可以方便地通过索引来访问每个元素。
  
  例如，遍历一个整数数组：
  int numbers[] = {1, 2, 3, 4, 5}; for (int i = 0; i < sizeof(numbers)/sizeof(numbers[0]); i++) { std::cout << numbers[i] << " "; }
  
  这里通过for循环的初始化部分定义了索引i，条件判断部分确保i在数组的有效范围内，更新部分i++让索引逐次增加，从而可以依次访问数组中的每个元素并输出。
  
  执行固定次数的操作
  
  当需要执行固定次数的重复任务时，for循环是很好的选择。例如，计算1到100的整数和：
  int sum = 0; for (int i = 1; i <= 100; i++) { sum += i; } std::cout << "1到100的整数和为：" << sum << std::endl;
  
  在这里，我们明确知道要从1加到100，共100次加法操作，for循环的初始化（i = 1）、条件判断（i <= 100）和更新（i++）部分很好地配合实现了这个固定次数的循环。
2. while循环适用场景
  
  基于条件的不确定次数循环
  
  当循环的结束条件取决于某个动态变化的条件，且在循环开始前无法确定循环次数时，while循环很适用。例如，从用户输入中读取数据，直到用户输入特定的值（如-1）结束：
  int input; std::cout << "请输入整数（输入-1结束）："; std::cin >> input; while (input!= -1) { std::cout << "你输入的是：" << input << std::endl; std::cout << "请输入整数（输入-1结束）："; std::cin >> input; }
  
  这个例子中，不知道用户会输入多少次数据，循环会一直执行，只要用户输入的不是-1，就会继续要求用户输入并输出输入的内容。
  
  等待某个状态改变的情况
  
  在一些程序中，需要等待某个外部设备状态改变或者某个变量达到特定值。例如，等待一个文件读取完成，通过检查表示文件读取状态的变量来决定是否继续等待：
  bool fileReadComplete = false; while (!fileReadComplete) { // 检查文件读取进度的代码，可能涉及到系统调用或者其他复杂操作 // 如果读取完成，将fileReadComplete设置为true }
3. do - while循环适用场景
  
  至少执行一次的操作循环
  
  当需要保证循环体中的代码至少执行一次，然后再根据条件判断是否继续循环时，do - while循环是最佳选择。例如，一个简单的菜单程序，需要先显示菜单，然后根据用户选择决定是否再次显示菜单：
  int choice; do { std::cout << "1. 开始游戏\n2. 查看帮助\n3. 退出" << std::endl; std::cin >> choice; switch (choice) { case 1: std::cout << "游戏开始！" << std::endl; break; case 2: std::cout << "这是帮助信息。" << std::endl; break; case 3: std::cout << "再见！" << std::endl; break; default: std::cout << "无效选择，请重新选择。" << std::endl; } } while (choice!= 3);
  
  这个菜单程序首先会显示菜单选项，用户做出选择后，根据选择执行相应操作，然后检查用户是否选择退出（choice!= 3），如果没有退出，就会再次显示菜单，保证菜单至少显示一次。
admin SU @ 2024-12-7 21:52:41
1. for循环执行流程
  
  初始化：首先执行循环的初始化部分，这部分通常用于声明和初始化一个循环变量。例如，for(int i = 0;...;... )，在这里int i = 0就是初始化部分，定义了一个整型变量i并将其初始化为0。这个步骤只在循环开始时执行一次。
  
  条件判断：接着会检查条件表达式。只要这个条件为真（在C++中，非零值表示真），就会执行循环体中的代码。例如，i < 10这个条件表达式，当i的值小于10时，循环会继续执行。
  
  循环体执行：如果条件判断为真，就会执行循环体中的代码。循环体是包含在for循环的花括号{}内的部分，这部分代码会根据条件的判断结果重复执行。
  
  更新操作：在每次循环体执行完毕后，会执行更新表达式。例如，i++会使循环变量i的值增加1。这个操作更新了循环变量，为下一次的条件判断做准备。
  
  循环结束条件：当条件表达式的值为假（即0）时，循环结束，程序继续执行循环后面的代码。
  
  示例代码：
  for(int i = 0; i < 5; i++) { std::cout << i << " "; } // 输出结果为：0 1 2 3 4
  
  在这个例子中，i从0开始，每次循环判断i是否小于5，然后在循环体中输出i的值，最后i自增1。当i等于5时，条件不满足，循环结束。
2. while循环执行流程
  
  初始化（在循环外）：在进入while循环之前，需要先对循环变量进行初始化。例如，int i = 0;在循环外部定义并初始化了一个变量i。
  
  条件判断：和for循环一样，while循环会先检查条件表达式。只要条件为真，就会执行循环体中的代码。例如，while(i < 5)，当i的值小于5时，循环会继续。
  
  循环体执行：如果条件判断为真，就执行循环体中的代码。循环体同样是花括号{}内的部分，这部分代码会根据条件的判断结果重复执行。
  
  更新操作（在循环内）：在循环体内部需要手动更新循环变量。例如，i++，这样才能使循环最终结束。如果忘记更新循环变量，可能会导致循环一直执行下去，形成死循环。
  
  循环结束条件：当条件表达式的值为假（即0）时，循环结束，程序继续执行循环后面的代码。
  
  示例代码：
  int i = 0; while(i < 5) { std::cout << i << " "; i++; } // 输出结果为：0 1 2 3 4
  
  这里，先在循环外初始化i为0，然后在每次循环中检查i是否小于5，在循环体中输出i的值后，通过i++更新i的值，直到i不小于5，循环结束。
3. do - while循环执行流程
  
  初始化（在循环外）：类似于while循环，在进入do - while循环之前，需要先对循环变量等进行初始化。例如，int i = 0;在循环外部定义并初始化变量。
  
  循环体执行：do - while循环的特点是先执行一次循环体中的代码，然后再进行条件判断。这意味着循环体至少会被执行一次。例如，do {... } while(i < 5);，会先执行一次循环体中的内容。
  
  条件判断：在循环体执行一次后，会检查条件表达式。只要条件为真，就会再次执行循环体中的代码。例如，当i < 5为真时，循环会继续执行。
  
  更新操作（在循环内）：在循环体内部需要手动更新循环变量，以确保循环能够正常结束。例如，通过i++来更新变量的值。
  
  循环结束条件：当条件表达式的值为假（即0）时，循环结束，程序继续执行循环后面的代码。
  
  示例代码：
  int i = 0; do { std::cout << i << " "; i++; } while(i < 5); // 输出结果为：0 1 2 3 4
  
  在此示例中，先初始化i为0，然后执行循环体，输出i的值并将i自增1。之后检查i是否小于5，如果是，则再次执行循环体，直到i不小于5，循环结束。
4. 三种循环的区别
  
  执行顺序：
  
  for循环是先初始化，然后进行条件判断，接着执行循环体，最后更新循环变量，再进行下一次条件判断，如此循环。
  
  while循环是先进行条件判断，只有条件为真时才执行循环体，在循环体内部更新循环变量，然后再进行条件判断，重复这个过程。
  
  do - while循环是先执行循环体，然后再进行条件判断，只要条件为真就继续执行循环体，在循环体内部更新循环变量，然后再进行条件判断，并且循环体至少会执行一次。
  
  使用场景：
  
  for循环适用于已知循环次数的情况，例如遍历一个固定大小的数组。例如，for(int i = 0; i < array_size; i++)，其中array_size是已知的数组大小，for循环可以很方便地遍历数组中的每个元素。
  
  while循环适用于不知道循环次数，但知道循环结束的条件的情况。例如，当从用户输入中读取数据，直到用户输入特定的值（如-1）来结束输入时，就可以使用while循环来不断读取输入并进行判断。
  
  do - while循环也适用于不知道循环次数的情况，但它强调循环体至少要执行一次。例如，一个简单的菜单程序，至少要显示一次菜单内容，然后根据用户的选择来决定是否继续显示菜单，就可以使用do - while循环来实现。
admin SU @ 2024-12-7 21:51:55
以下是使用C++语言中的do-while循环来打印100以内奇数的两种常见代码示例，并且都附带了详细注释，帮助你理解代码的逻辑思路：

方法一：通过每次让变量自增2来实现（利用奇数特性）
```
#include <iostream>
using namespace std;

int main() {
    int num = 1;  // 初始化变量num为1，从最小的奇数开始
    do {
        cout << num << " ";  // 输出当前的奇数
        num += 2;  // 让num每次增加2，保证其始终为奇数
    } while (num < 100);  // 循环条件，只要num小于100，就继续循环
    cout << endl;  // 循环结束后输出换行符，使输出更美观

    return 0;
}
```
在这个示例中：
- 首先将变量 num 初始化为 1，因为 1 是最小的奇数，这是我们要打印的奇数序列的起始值。
- 接着进入 do-while 循环，它的特点是先执行一次循环体中的代码，也就是先输出当前的奇数 num，然后通过 num += 2 让 num 的值增加 2，使得 num 始终保持为奇数。
- 之后再判断 while 后面的条件 num < 100，只要这个条件为真，也就是 num 的值还小于 100，就会再次执行循环体，重复输出奇数以及更新 num 的操作。当 num 不满足小于 100 的条件时，循环结束，最后输出一个换行符来规范输出的格式，让结果看起来更整齐。
方法二：通过取余判断是否为奇数来实现
```
#include <iostream>
using namespace std;

int main() {
    int num = 0;  // 初始化变量num为0
    do {
        if (num % 2!= 0) {  // 通过取余运算判断num是否为奇数，余数不为0则是奇数
            cout << num << " ";  // 如果是奇数，就输出该数
        }
        num++;  // 每次循环让num自增1，依次检查每个数是否为奇数
    } while (num < 100);  // 循环条件，保证处理的数在100以内
    cout << endl;

    return 0;
}
```
在这段代码里：
- 先把变量 num 初始化为 0，然后进入 do-while 循环。由于 do-while 循环的特性，会先执行一次循环体的内容。
- 在循环体中，通过 if 语句结合取余运算 num % 2 来判断 num 是否为奇数，当余数不为 0 时，说明 num 是奇数，此时就会输出这个奇数。接着通过 num++ 让 num 的值自增 1，准备检查下一个数是否为奇数。
- 完成一次循环体的执行后，再判断 while 后面的条件 num < 100，若该条件满足，就会继续执行循环体，如此反复，直到 num 不小于 100 了，循环结束，最后输出换行符来完善输出的显示效果，使得打印出来的奇数呈现出更规范的排列形式。
admin SU @ 2024-12-7 21:51:22
以下是使用C++语言中的while循环来打印100以内奇数的两种常见代码示例，并且附带了详细注释，方便你理解代码逻辑：

方法一：通过控制变量每次自增2来实现
```
#include <iostream>
using namespace std;

int main() {
    int num = 1;  // 初始化变量num为1，从最小的奇数开始
    while (num < 100) {  // 只要num小于100，就继续循环，确保在100以内
        cout << num << " ";  // 输出当前的奇数
        num += 2;  // 让num每次增加2，这样始终保持为奇数
    }
    cout << endl;  // 循环结束后输出换行符，使输出更美观

    return 0;
}
```
在这个示例中：
- 首先定义并初始化变量 num 为 1，它作为要打印的奇数序列的起始值。
- 接着进入 while 循环，循环的条件是 num < 100，意味着只要 num 的值小于 100，循环就会持续执行。
- 在循环体内部，先输出当前的奇数 num，然后通过 num += 2 让 num 的值增加 2，这样 num 在下一次循环时依然是奇数，如此反复，直到 num 不满足小于 100 的条件，循环结束，最后输出一个换行符来规范输出的格式。
方法二：通过取余判断是否为奇数来实现
```
#include <iostream>
using namespace std;

int main() {
    int num = 0;  // 初始化变量num为0
    while (num < 100) {  // 循环条件，保证处理的数在100以内
        if (num % 2!= 0) {  // 通过取余运算判断num是否为奇数，余数不为0则是奇数
            cout << num << " ";  // 如果是奇数，就输出该数
        }
        num++;  // 每次循环让num自增1，依次检查每个数是否为奇数
    }
    cout << endl;

    return 0;
}
```
在这段代码里：
- 先把变量 num 初始化为 0，随后进入 while 循环，只要 num 的值小于 100，循环就会不断执行下去。
- 在循环体中，使用 if 语句结合取余运算 num % 2 判断 num 是否为奇数，若余数不为 0，说明 num 是奇数，此时就会输出这个奇数。
- 每次循环结束时，通过 num++ 让 num 的值自增 1，这样就能逐个检查 0 到 99 这些数是否为奇数，并输出所有的奇数，循环结束后输出换行符来完善输出的显示效果。
admin SU @ 2024-12-7 21:50:49
以下是使用C++语言中的for循环来打印100以内奇数的代码示例，代码中添加了详细注释方便你理解其逻辑：
```
#include <iostream>
using namespace std;

int main() {
    // for循环的初始化部分，定义一个整型变量i并初始化为1，从最小的奇数开始
    for (int i = 1; 
         // 条件表达式，只要i小于100就继续循环，保证只处理100以内的数
         i < 100; 
         // 更新表达式，每次循环让i增加2，这样就能保证i始终是奇数
         i += 2) {
        // 在循环体中输出当前的奇数i
        cout << i << " ";
    }
    cout << endl;  // 循环结束后输出一个换行符，使输出结果更美观

    return 0;
}
```
在上述代码中：
- for循环的初始化部分 int i = 1 创建了一个整型变量 i 并初始化为 1，作为起始的奇数。
- 条件表达式 i < 100 限定了循环的范围，只要 i 的值小于 100，循环就会持续执行下去，确保只处理 100 以内的数字。
- 更新表达式 i += 2 让变量 i 在每次循环结束后增加 2，这样 i 始终保持为奇数，依次遍历了 100 以内的所有奇数并进行输出。最后通过 cout << endl; 输出一个换行符来让整个输出结果在终端上的显示更加整齐规范。
当然，也可以用另一种常见的思路来实现，代码如下：
```
#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 100; i++) {  // 初始化i为0，范围是小于100
        if (i % 2!= 0) {  // 通过取余运算判断i是否为奇数，如果余数不为0则是奇数
            cout << i << " ";
        }
    }
    cout << endl;

    return 0;
}
```
这段代码里，for 循环先初始化 i 为 0，然后每次循环让 i 自增 1，在循环体内部通过 if 语句使用取余运算 i % 2 判断 i 是否为奇数（奇数除以 2 的余数不为 0），如果是奇数就进行输出，同样能实现打印 100 以内奇数的功能。

C++循环教程

C++循环教程

1. 为什么需要循环？

2. for循环

3. while循环

4. do - while循环

5. 循环嵌套

6 条评论

方法一：通过每次让变量自增2来实现（利用奇数特性）

方法二：通过取余判断是否为奇数来实现

方法一：通过控制变量每次自增2来实现

方法二：通过取余判断是否为奇数来实现

状态

开发

支持

C++循环教程

C++循环教程

1. 为什么需要循环？

2. for循环

3. while循环

4. do - while循环

5. 循环嵌套

6 条评论

方法一：通过每次让变量自增2来实现（利用奇数特性）

方法二：通过取余判断是否为奇数来实现

方法一：通过控制变量每次自增2来实现

方法二：通过取余判断是否为奇数来实现

状态

开发

支持

还没有账户？

登录