第六章语句

2023-10-15 13:41:20 浏览数 (1)

语句基础

语句的常见类别

  • 表达式语句：表达式后加分号，对表达式求值后丢弃，可能产生副作用
  • 空语句：仅包含一个分号的语句，可能与循环一起工作
  • 复合语句（语句体）：由大括号组成，无需在结尾加分号，形成独立的域（语句域） ——>更好的控制对象的生命周期
代码语言：javascript复制
int main()
{
    // 注意下面实际上是两条语句：复合语句和空语句
    {cc  
        // ...
    };
}

顺序语句与非顺序语句

  • 顺序语句
    • 从语义上安装先后顺序执行
    • 实际的执行顺序可能产生变化（编译器优化、硬件乱序执行）
    • 与硬件流水线紧密结合，执行效率较高
  • 非顺序执行
    • 在执行过程中引入跳转，从而产生复杂的变化
    • 分支预测错误可能导致执行性能降低

最基本的非顺序语句：goto

代码语言：javascript复制
#include <iostream>
int main()
{
    int x = 3;
    if (x) goto label;
    x = x   1;
label:
    return 0;
}
  • 通过标签指定跳转到的位置
  • 具有若干限制
    • 不能跨函数跳转
    • 向前跳转时不能越过对象初始化语句
  • 向后跳转可能会导致对象销毁与重新初始化

goto本质上对应了汇编语言中的跳转指令

  • 缺乏结构性的含义
  • 容易造成逻辑混乱
  • 除特殊情况外，应避免使用

分支语句

if

  • 语法：https://zh.cppreference.com/w/cpp/language/if
  • 使用语句块表示复杂的分支逻辑
  • 从if到if-else
    • 实现多重分支
    • else会与最近的if匹配
    • 使用大括号改变匹配规则
代码语言：javascript复制
// 一个不合原意的应用
// grade > 80 --> Excellent
// grade <= 60 --> Bad

int grade = 65;
if (grade > 60)
    if (grade > 80)
        std::cout << "Excellentn";
else
    std::cout << "Badn";
  • if V.S. constexpr if —— 运行期与编译器分支
代码语言：javascript复制
constexpr int grade = 80;
if constexpr (grade < 60)
{
    //...
}
  • 带初始化的if
代码语言：javascript复制
int x = 3;
// y的作用域为if-else语句范围内
if (int y = x * 3; y > 100)
{
    std::cout << y << 'n';
}
else
{
    std::cout << -y << 'n';
}

switch

  • 语法：https://zh.cppreference.com/w/cpp/language/switch
  • 条件部分应当能够隐式转换为整型或枚举类型，可以包含初始化的语句
  • case/default标签
    • case后面跟常量表达式（即在编译期可以求值的式子），用于匹配switch中的条件，匹配时执行后续的代码
    • 可以使用break跳出当前的switch执行
    • default用于定义缺省情况下的逻辑
    • 在case/default中定义对象要加大括号
代码语言：javascript复制
int x;
switch (std::cin >> x; x)
{
    case 3:
        std::cout << "Hellon";  // fall through
    case 4:
        std::cout << "Worldn";
}
  • [[fallthrough]]属性
代码语言：javascript复制
int x;
switch (std::cin >> x; x)
{
    case 3:
        std::cout << "Hellon";
        [[fallthrough]];
    case 4:
        std::cout << "Worldn";
}
  • 与if相比的优劣
    • 分支描述能力较弱
    • 在一些情况下能引入更好的优化

循环语句

while

  • 语法：https://zh.cppreference.com/w/cpp/language/while
  • 处理逻辑：
    1. 判断条件是否满足，如果不满足则跳出循环
    2. 如果条件满足则执行循环体
    3. 执行完循环体后转向步骤1
  • 注意：在while的条件部分不包含额外的初始化内容

do-while

  • 语法：https://zh.cppreference.com/w/cpp/language/do
    • 注意结尾处要有分号，表示一条语句的结束
  • 处理逻辑：
    1. 执行循环体
    2. 断条件是否满足，如果不满足则跳出循环
    3. 如果条件满足则转向步骤1
  • 注：do-while中条件处不支持带花括号或等号初始化器的单个变量的声明。
代码语言：javascript复制
// 错误的语句
do
{
    // ...
} while (int x = 0);

for

  • 语法：https://zh.cppreference.com/w/cpp/language/for
  • 处理逻辑：
    1. 初始化语句会被首先执行
    2. 条件部分会被执行，执行结果如果为false，则终止循环
    3. 否则执行循环体
    4. 迭代表达式会被求值，之后转向2
  • 在初始化语句中声明多个名字
代码语言：javascript复制
for (int i = 0, *p = &i; i < 9; i  = 2)
{
    std::cout << i << ' : ' << *p << ' ';
}
std::cout << 'n';
  • 初始化语句、条件、迭代表达式可以为空
    • 条件若为空语句则系统默认为TRUE
  • for的更多示例

基于范围的for循环

  • 语法：https://zh.cppreference.com/w/cpp/language/range-for
  • 本质：语法糖，编译器会转换为for循环的调用方式
  • 转换形式的衍化：C 11/C 17/C 20
  • 使用常量左值引用读元素；使用“万能引用(universal reference)-> auto &&”修改元素
代码语言：javascript复制
{
    // C  17标准
    auto && __range = 范围表达式;
    for (auto __begin = 首表达式, __end = 尾表达式; __begin != __end;   __begin)
    {
        范围声明 = *__begin;
        // 循环语句...
    }
}
代码语言：javascript复制
std::vector<std::string> arr{"h", "e", "l"};
for (const std::string & v : arr)
    std::cout << v << 'n';

break/continue

  • 含义（转自cpp reference）
    • break：导致外围的for、范围for、while或do-while循环或switch语句终止
    • continue：用于跳过整个for、while或do-while循环体的剩余部分
  • 注意这二者均不能用于多重嵌套循环，多重嵌套循环的跳转可以考虑goto语句

语句的综合应用——达夫设备

  • 使用循环展开提升系统性能
  • 处理无法整除的情形
    • 额外增加一个循环语句 ——> 循环展开
    • 将switch与循环结合——达夫设备
代码语言：javascript复制
#include <iostream>
#include <vector>

int main (void)
{
    constexpr size_t buffer_count = 10000;
    std::vector<size_t> buffer(buffer_count);
    for (size_t i = 0; i < buffer_count;   i)
    {
        buffer[i] = i;
    }

    size_t max_value = buffer[0];
    auto ptr = buffer.begin();
    switch (buffer_count % 8)
    {
        case 0 : max_value = (max_value > *ptr) ? max_value : *ptr;   ptr; [[fallthrough]];
        case 7 : max_value = (max_value > *ptr) ? max_value : *ptr;   ptr; [[fallthrough]];
        case 6 : max_value = (max_value > *ptr) ? max_value : *ptr;   ptr; [[fallthrough]];
        case 5 : max_value = (max_value > *ptr) ? max_value : *ptr;   ptr; [[fallthrough]];
        case 4 : max_value = (max_value > *ptr) ? max_value : *ptr;   ptr; [[fallthrough]];
        case 3 : max_value = (max_value > *ptr) ? max_value : *ptr;   ptr; [[fallthrough]];
        case 2 : max_value = (max_value > *ptr) ? max_value : *ptr;   ptr; [[fallthrough]];
        case 1 : max_value = (max_value > *ptr) ? max_value : *ptr;   ptr;
    };

    for (size_t i = 0; i < (buffer_count - 1) / 8;   i)
    {
        max_value = (max_value > *ptr) ? max_value : *ptr;   ptr;
        max_value = (max_value > *ptr) ? max_value : *ptr;   ptr;
        max_value = (max_value > *ptr) ? max_value : *ptr;   ptr;
        max_value = (max_value > *ptr) ? max_value : *ptr;   ptr;
        max_value = (max_value > *ptr) ? max_value : *ptr;   ptr;
        max_value = (max_value > *ptr) ? max_value : *ptr;   ptr;
        max_value = (max_value > *ptr) ? max_value : *ptr;   ptr;
        max_value = (max_value > *ptr) ? max_value : *ptr;   ptr;
    }

    for (size_t i = buffer_count / 8 * 8; i < buffer_count;   i)
    {
        max_value = (max_value > buffer[i])       ? max_value : buffer[i]      ;
    }
    std::cout << max_value << 'n';
}
代码语言：javascript复制
#include <iostream>
#include <vector>

int main (void)
{
    constexpr size_t buffer_count = 10000;
    std::vector<size_t> buffer(buffer_count);
    for (size_t i = 0; i < buffer_count;   i)
    {
        buffer[i] = i;
    }

    size_t max_value = buffer[0];
    auto ptr = buffer.begin();

    size_t i = 0;
    switch (buffer_count % 8) {
        for (; i < (buffer_count   7) / 8;   i) {
            case 0 :
                max_value = (max_value > *ptr) ? max_value : *ptr;
              ptr; [[fallthrough]];
            case 7 :
                max_value = (max_value > *ptr) ? max_value : *ptr;
              ptr; [[fallthrough]];
            case 6 :
                max_value = (max_value > *ptr) ? max_value : *ptr;
              ptr; [[fallthrough]];
            case 5 :
                max_value = (max_value > *ptr) ? max_value : *ptr;
              ptr; [[fallthrough]];
            case 4 :
                max_value = (max_value > *ptr) ? max_value : *ptr;
              ptr; [[fallthrough]];
            case 3 :
                max_value = (max_value > *ptr) ? max_value : *ptr;
              ptr; [[fallthrough]];
            case 2 :
                max_value = (max_value > *ptr) ? max_value : *ptr;
              ptr; [[fallthrough]];
            case 1 :
                max_value = (max_value > *ptr) ? max_value : *ptr;
              ptr;
        }
    }

    std::cout << max_value << 'n';
}
```cc
case max 编译器 对象 语法

0 人点赞