c++语句详细介绍

---

前言

这篇简单介绍一下c++语句，主要有简单语句、语句作用域、条件语句、迭代语句以及异常处理机制

---

简单语句

在C++中，简单语句是构成程序的基础单元。它们通常执行单一的操作，并以分号(;)结束。以下是C++中常见的几种简单语句类型：

1. 表达式语句：这是最常见的简单语句类型，它包括表达式后跟一个分号。例如，赋值操作、函数调用、算术运算等。

   a = 5;     // 赋值语句
   a++;       // 后缀递增
   func();    // 函数调用
   

   #include 
   
   int main() {
       int a = 5;  // 赋值语句
       a++;        // 后缀递增表达式
       std::cout << a << std::endl; // 输出表达式
       return 0;
   }
   

2. 声明语句：用于声明变量。在C++中，变量在使用前必须声明。声明语句也是简单语句的一种。

   int a;      // 声明一个整型变量a
   double b;   // 声明一个双精度浮点变量b
   

   #include 
   
   int main() {
       int a;  // 声明一个整型变量a
       a = 10; // 赋值
       std::cout << a << std::endl;
       return 0;
   }
   

3. 返回语句（return）：在函数中使用，用于返回函数的结果并退出函数。

   return;        // 无返回值的函数中使用
   return x + y;  // 返回表达式的结果
   

4. 空语句：只包含一个分号，不执行任何操作。在某些情况下，空语句可以用于占位或表示循环体或条件体为空。

   ;  // 一个空语句
   

5. 复合语句（或块）：虽然不是简单语句，但它由花括号（{}）包围的一系列语句构成，通常用于定义变量的作用域。

   {
       int a = 5;   // a的作用域限于这个复合语句
       a++;
   }
   

语句作用域

在C++中，语句作用域指的是程序中变量和函数的可见性与有效性的范围。以下是C++中作用域的几种主要类型：

1. 局部作用域

• 局部作用域通常指在函数或代码块（如if、for语句块）内声明的变量。
• 这些变量只在声明它们的块或函数内部可见和有效。
• 示例代码：

  #include 
  
  void myFunction() {
      int a = 5; // a的作用域限于myFunction
      std::cout << "Inside myFunction, a = " << a << std::endl;
  }
  
  int main() {
      myFunction();
      // std::cout << a; // 这里访问a将引发编译错误，因为a的作用域只在myFunction内
      return 0;
  }
  

2. 全局作用域

• 全局变量在所有函数外部定义，它们在整个程序中都是可见和有效的。
• 示例代码：

  #include 
  
  int x = 20; // 全局变量x
  
  void myFunction() {
      std::cout << "Inside myFunction, x = " << x << std::endl; // 可以访问全局变量x
  }
  
  int main() {
      myFunction();
      std::cout << "In main, x = " << x << std::endl;
      return 0;
  }
  

3. 命名空间作用域

• 命名空间提供了一种将全局变量和函数组织在一起的方式，避免名称冲突。
• 示例代码：

  #include 
  
  namespace MyNamespace {
      int value = 5; // MyNamespace作用域内的变量
  }
  
  int main() {
      std::cout << "Value in MyNamespace: " << MyNamespace::value << std::endl;
      // 访问命名空间内的变量需要使用命名空间名称
      return 0;
  }
  

4. 块作用域

• 块作用域是指由花括号{}定义的代码块内声明的变量，它们的作用域限制在这个块内。
• 示例代码：

  #include 
  
  int main() {
      {
          int a = 10; // a的作用域限于这个块
          std::cout << "Inside block, a = " << a << std::endl;
      }
      // std::cout << a; // 这里访问a将引发编译错误，因为a的作用域已结束
      return 0;
  }
  

条件语句

在C++中，条件语句用于基于特定条件执行不同的代码路径。C++提供了几种条件语句，包括if、else if、else和switch。下面是对这些条件语句的详细介绍：

1. If语句

• 基本形式：if语句用于在满足特定条件时执行一段代码。

  if (condition) {
      // 执行代码
  }
  

• 示例：

  int a = 10;
  if (a > 5) {
      std::cout << "a大于5" << std::endl;
  }
  

2. Else语句

• 与If结合：else语句用于在if条件不满足时执行另一段代码。

  if (condition) {
      // 条件满足时执行
  } else {
      // 条件不满足时执行
  }
  

• 示例：

  int a = 3;
  if (a > 5) {
      std::cout << "a大于5" << std::endl;
  } else {
      std::cout << "a小于或等于5" << std::endl;
  }
  

3. Else If语句

• 多重条件：else if用于在多个条件之间做出选择。

  if (condition1) {
      // 条件1满足时执行
  } else if (condition2) {
      // 条件2满足时执行
  } else {
      // 以上条件都不满足时执行
  }
  

• 示例：

  int score = 85;
  if (score >= 90) {
      std::cout << "优秀" << std::endl;
  } else if (score >= 60) {
      std::cout << "及格" << std::endl;
  } else {
      std::cout << "不及格" << std::endl;
  }
  

4. Switch语句

• 选择控制：switch语句根据变量的值选择执行不同的代码分支。

  switch (expression) {
      case value1:
          // value1时执行
          break;
      case value2:
          // value2时执行
          break;
      // 更多cases
      default:
          // 没有匹配时执行
  }
  

• 示例：

  char grade = 'B';
  switch (grade) {
      case 'A':
          std::cout << "优秀" << std::endl;
          break;
      case 'B':
      case 'C':
          std::cout << "良好" << std::endl;
          break;
      case 'D':
          std::cout << "及格" << std::endl;
          break;
      default:
          std::cout << "不及格" << std::endl;
  }
  

5. 嵌套条件语句

• 条件语句可以嵌套使用，以构建复杂的逻辑。

  if (condition1) {
      // ...
      if (condition2) {
          // ...
      }
  }
  

6. 条件运算符

• C++还提供了三元条件运算符?:，用于简洁的条件表达。

  int a = 10, b = 5;
  int max = (a > b) ? a : b;  // 如果a > b，max = a，否则max = b
  

循环语句

在C++中，循环语句用于重复执行一段代码多次，直到满足某个特定的条件。C++提供了几种循环语句，包括while循环、do-while循环和for循环。以下是这些循环语句的详细介绍：

1. While循环

• 用途：当给定的条件为真时，重复执行代码块。

• 格式：

  while (condition) {
      // 循环体
  }
  

• 特点：循环开始前会检查条件。如果初始条件为假，则循环体一次也不执行。

  #include 
  int main() {
      int i = 0;
      while (i < 5) {
          std::cout << i << std::endl;
          i++;
      }
      return 0;
  }
  

2. Do-While循环

• 用途：至少执行一次代码块，然后在条件为真时重复执行。
• 格式：

  do {
      // 循环体
  } while (condition);
  

• 特点：循环体至少执行一次，因为条件检查发生在循环体之后。

  #include 
  int main() {
      int i = 0;
      do {
          std::cout << i << std::endl;
          i++;
      } while (i < 5);
      return 0;
  }
  

3. For循环

• 用途：重复执行代码块，通常用于执行已知次数的循环。
• 格式：

  for (initialization; condition; increment) {
      // 循环体
  }
  

• 特点：包括初始化表达式、循环条件和迭代表达式。

  #include 
  int main() {
      for (int i = 0; i < 5; i++) {
          std::cout << i << std::endl;
      }
      return 0;
  }
  

4. 范围Based For循环（C++11及以上版本）

• 用途：遍历容器（如数组或向量）中的每个元素。

• 格式：

  for (declaration : container) {
      // 循环体
  }
  

• 特点：简化了对容器的遍历操作。

  #include 
  #include 
  int main() {
      std::vector<int> vec = {1, 2, 3, 4, 5};
      for (int v : vec) {
          std::cout << v << std::endl;
      }
      return 0;
  }
  

跳转语句

在C++中，跳转语句用于改变程序的控制流，使其从一个位置跳转到另一个位置。C++提供了几种跳转语句：break、continue、goto和return。这些语句在不同的上下文中有不同的用途和影响。以下是对这些跳转语句的详细介绍：

1. Break语句

• 用途：用于立即终止最接近的封闭的switch语句或循环（for、while、do-while）。
• 示例：在for循环中使用break跳出循环。

  for (int i = 0; i < 10; i++) {
      if (i == 5) {
          break; // 当i等于5时跳出循环
      }
      std::cout << i << " ";
  }
  

2. Continue语句

• 用途：跳过当前循环的剩余部分，并继续下一次循环的迭代。
• 示例：在for循环中使用continue跳过某些迭代。

  for (int i = 0; i < 10; i++) {
      if (i % 2 == 0) {
          continue; // 跳过偶数迭代
      }
      std::cout << i << " ";
  }
  

3. Goto语句

• 用途：无条件跳转到同一函数内的标记位置。
• 注意：虽然goto可以用于复杂的流程控制，但过度使用可能导致代码难以理解和维护，因此一般不推荐使用。
• 示例：跳转到标记的位置。

  goto label;
  std::cout << "This will be skipped";
  label:
  std::cout << "Jumped to label";
  

4. Return语句

• 用途：从函数中返回一个值（如果函数有返回类型），或者结束一个void类型的函数的执行。
• 示例：在函数中返回一个值。

  int add(int a, int b) {
      return a + b; // 返回a和b的和
  }
  

try语句块和异常处理

在C++中，异常处理是一种用于处理程序运行时可能发生的错误和异常情况的机制。异常处理的核心包括三个关键部分：try块、catch块和throw语句。这种机制提供了一种将错误检测和处理代码与正常逻辑代码分离的方法，从而使得代码更加清晰、可维护。

1. Try块

• 用途：try块用于包含可能抛出异常的代码。如果try块中的代码抛出了异常，控制流将跳转到匹配的catch块。
• 格式：

  try {
      // 可能抛出异常的代码
  }
  

2. Catch块

• 用途：catch块用于捕获和处理特定类型的异常。可以有多个catch块来处理不同类型的异常。
• 格式：

  catch (异常类型 参数) {
      // 处理异常的代码
  }
  

3. Throw语句

• 用途：throw语句用于抛出一个异常。可以抛出任何类型的数据，但通常是派生自std::exception的类的对象。
• 格式：

  throw 异常对象;
  

4. 标准异常

• C++标准库提供了一系列标准异常类，它们都派生自std::exception。这些异常类包括std::runtime_error、std::out_of_range等。
• 使用标准异常类可以使错误信息更标准化、易于理解。

代码示例

以下示例展示了如何在C++中使用异常处理：

#include 
#include  // 包含标准异常类

void testFunction(int a) {
    if (a == 0) {
        throw std::invalid_argument("a不能为0"); // 抛出异常
    }
    std::cout << "a的值是 " << a << std::endl;
}

int main() {
    try {
        testFunction(0); // 这将抛出一个异常
    } catch (const std::invalid_argument& e) {
        std::cerr << "捕获到异常: " << e.what() << std::endl;
    }
    return 0;
}

在这个示例中，如果testFunction接收到的参数为0，它将抛出std::invalid_argument异常。main函数中的try块尝试调用testFunction，并使用catch块来捕获和处理可能出现的异常。

总结

这篇主要讲了

简单语句，

语句作用域：变量和函数在程序中的可见性和有效性范围

条件语句：包括if、else if、else和switch语句，

迭代语句：涵盖了while、do-while和for循环，用于执行重复的操作，直到满足某个特定条件。

异常处理：使用try、catch和throw的异常处理机制，这对于编写能够优雅处理错误和异常情况的程序至关重要。

肝完，下一篇讲什么呢？