C++_Chapter 5 语句

最新推荐文章于 2024-07-11 13:30:38 发布
最新推荐文章于 2024-07-11 13:30:38 发布
阅读量95 收藏
点赞数
分类专栏： C++ 文章标签： c++ visual studio 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/satisfiedmin/article/details/124929256
版权

Chapter 5 语句

5-1 语句基础

语句的常见类别

  • 表达式语句：表达式后加分号；

    int x;
x = 3;

  • 空语句

    ;

  • 复合语句（语句体）：由大括号组成，无需在结尾加分号，形成独立的域（语句域）

    int x = 2;
{
	int x = 3;
	x = x + 1;
	std::cout << x;
}
顺序语句与非顺序语句

  • 顺序语句

    int x = 0;
++x;
int y = 6;
--y;
    • 从语义上按照先后顺序执行
    • 实际的执行顺序可能会由于编译器优化、硬件乱序执行发生变化
    • 与硬件流水线紧密结合，执行效率较高

  • 非顺序语句

    • 在执行过程中引入跳转，从而产生复杂的变化
    • 分支预测错误可能会导致执行性能降低

  • goto

    int main()
{
    int x = 3;
    if (x) goto label;
    x = x + 1;
label:
    return 0;
}

    具有若干限制：

    1. 不能跨函数跳转；
    2. 向前跳转时不能越过对象初始化语句
    int main()
{
	int x = 3;
	goto label; // 前向跳转
	int y = 4;
	label:
	y = y + 1;
}

    后向跳转可能会导致对象的销毁或重新初始化

    	bool flag = true;
label:
	int x = 3;
	if (flag)
	{
		flag = false;
		goto label;
}

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

    • 缺乏结构性含义；

    • 容易造成逻辑混乱；

    • 除特殊情况外，应避免使用。

5-2 分支语句

if语句

if (条件) true分支语句

if (条件) true分支语句 else false分支语句

int main()
{
    int x = -1;
	if (x > 2)
    {
        int y = 3 * x;
        std::cout << y << '\n';
    }
    else
    {
        if (x > 0)
            std::cout << "x > 0\n";
        else
            std::cout << "x <= 0\n";
    }
}

else会与最近的if相匹配

if V.S. constexpr if——运行期与编译器分支

int main()
{
	constexpr int grade = 80;
    if constexpr (grade < 60) // 肯定不会被执行，会直接注释掉
    {
        std::cout << "fail\n";
    }
    else
    {
        std::cout << "pass\n";
        if constexpr (grade == 100)
        {
            std::cout << "excellent!\n"
        }
        else
        {
            std::cout << "not bad\n";
        }
    }
}

带初始化的if

int x = 3;
//希望执行if后，y被删除
{
int y = x * 3;
if (y > 100)
{

}
else
{

}   
}//不利于阅读
if (int y = x * 3; y > 100)
{
    
}
else
{
    
}
int y = 4;//与上述y不冲突
switch语句
int x = 3;
switch (x + 1)
	std::cout << "Hello\n";

case/default标签

int x;
std::cin >> x;
switch (x)
{
    case 3:
        std::cout << "Hello\n"; // fall through
        [[fallthrough]];
    case 4:
        std::cout << "World\n";
        break;
    default:
        std::cout << "China\n";
        break;
}
//case后面跟常量表达式, 用于匹配switch 中的条件，匹配时执行后续的代码
// 可以使用break跳出当前的switch执行

case和default中定义对象需要加大括号

int x;
std::cin >> x;
switch (x)
{
    case 3:
        {
        	int y = 4;
        	std::cout << "Hello\n"; // fall through
        	break;
        }
    case 4:
        std::cout << "World\n";
        break;
    default:
        std::cout << "China\n";
        break;
}

[[fallthrough]]属性

相比if：

  1. 分支描述能力较弱；
  2. 在一些情况下能够更好地优化。

5-3 循环语句

while

while (条件) 语句

int x = 3;
while (x)
{
	std::cout << x << std::endl;
    --x;
}

注意：在while条件部分不包含额外的初始化内容

do-while

do 语句 while (表达式)

do
{
	std::cout << x << std::endl;
    --x;
}while(x);	// do-while不支持初始化变量
for

for (初始化语句 条件; 迭代表达式) 语句

for (int x = 0; x < 5; ++x)
{
	std::cout << x << std::endl;
}

int main()
{
	for (int i, *p = &i; i < 9; i +=2)
    {
        
    }
}
基于范围的for循环

for (范围声明 : 范围表达式)

# include <iostream>
# include <vector>

int main()
{
    std::vector<int> arr{1,2,3,4,5};
    for (int v : arr)
    {
        std::cout << v << '\n';
    }
}
break/continue

break：导致循环/switch跳出

continue：跳过整个循环体剩余 的部分

如果要跳出多重嵌套循环，可以考虑使用goto语句

5-4 达夫设备

int main()
{
	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_valude = buffer[0];
    for (size_t i = 0; i < buffer_count; i += 8)
    {
        max_value = (max_valude>buffer[i]) ? max_value : buffer[i];
        max_value = (max_valude>buffer[i+1]) ? max_value : buffer[i+1];
        max_value = (max_valude>buffer[i+2]) ? max_value : buffer[i+2];
        max_value = (max_valude>buffer[i+3]) ? max_value : buffer[i+3];
        max_value = (max_valude>buffer[i+4]) ? max_value : buffer[i+4];
        max_value = (max_valude>buffer[i+5]) ? max_value : buffer[i+5];
        max_value = (max_valude>buffer[i+6]) ? max_value : buffer[i+6];
        max_value = (max_valude>buffer[i+7]) ? max_value : buffer[i+7];
    }// 这一块的逻辑通过循环进行遍历，结果没有问题，处理速度也相对较快，但for循环内部的迭代表达式和条件比较慢，成本高 ---> 循环展开
        
    std::cout << max_value << std::endl;
}

如果buffer_count是10001(不能被8整除)怎么办？

  • 方案1：
int main()
{
	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_valude = buffer[0];
    for (size_t i = 0; i < buffer_count; i += 8)
    {
        max_value = (max_valude>buffer[i]) ? max_value : buffer[i];
        max_value = (max_valude>buffer[i+1]) ? max_value : buffer[i+1];
        max_value = (max_valude>buffer[i+2]) ? max_value : buffer[i+2];
        max_value = (max_valude>buffer[i+3]) ? max_value : buffer[i+3];
        max_value = (max_valude>buffer[i+4]) ? max_value : buffer[i+4];
        max_value = (max_valude>buffer[i+5]) ? max_value : buffer[i+5];
        max_value = (max_valude>buffer[i+6]) ? max_value : buffer[i+6];
        max_value = (max_valude>buffer[i+7]) ? max_value : buffer[i+7];
    }
    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 << std::endl;
}
  • 方案2：
int main()
{
	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_valude = buffer[0];
    auto ptr = buffer.begin();
    for (size_t i = 0; i < buffer_count; i += 8)
    {
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
    }
    
    switch (buffer_count % 8)
    {
        case 7: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 6: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 5: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 4: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 3: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 2: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 1: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;
    }
      
    std::cout << max_value << std::endl;
}
  • 方案3：
int main()
{
	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_valude = buffer[0];
    auto ptr = buffer.begin();
    
switch (buffer_count % 8)
    {
        case 0: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 7: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 6: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 5: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 4: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 3: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 2: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 1: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;
    }
    
    for (size_t i = 0; i < (buffer_count - 1) / 8; ++i)
    {
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
        max_value = (max_valude > *ptr) ? max_value : *ptr;
        ++ptr;
    }
    
    std::cout << max_value << std::endl;
}
  • 方案4：
int main()
{
	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_valude = buffer[0];
    auto ptr = buffer.begin();
size_t i = 0；    
switch (buffer_count % 8)
    for (; i < (buffer_count + 7) / 8; ++i)
    {[[fallthrough]];
        case 0: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 7: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 6: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 5: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 4: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 3: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 2: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;[[fallthrough]];
        case 1: max_value = (max_valude > *ptr) ? max_value : *ptr;++ptr;
    }
    
    std::cout << max_value << std::endl;
}
satisfiedmin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++_Chapter 2 对象与基本类型
satisfiedmin的博客
05-15 175
Chapter 2 对象与基本类型
6265513.rar_C/C++_
08-11
描述中提到的"windows 程序设计源码1-5"暗示了这是一个关于Windows平台上的C或C++程序设计的学习资源，包含了从第一章到第五章的源代码示例。 在C/C++编程领域，学习通常会按照章节进行，每个章节对应特定的概念或...
Python--X[:,0],X[:,1],X[:,3]的区别
qwer492915298的博客
03-19 1万+
X[:,0]是numpy中数组的一种写法，主要用于获取数组中的元素 X[:,0]---第一位元素数组 X[:,1]---第二位元素的数组 X[:,2]----第三位元素数组 代码 import numpy as np X = np.array([[2,1,1],[4,3,2],[6,5,3],[1,7,4],[7,9,5],[12,11,6],[16,13,7],[17,15,8],...
python x[:] x[::] x[:::]用法
热门推荐
Linias的博客
09-17 4万+
python x[:] x[::]用法总结 x[:,0] #　二维数组取第１维所有数据 x[:,1] # 第２列 x[0,:] # 第１行 x[3,:] # 第4行 x[1:4,:] # 第一二三行   x[:,n]或者x[n,:] x[:,n]表示在全部数组（维）中取第n个数据，直观来说，x[:,n]就是取所有集合的第n个数据,    x[n,:]表示在n个数组（维）中取全部数据，...
python x[:] x[::]用法总结
weixin_30394633的博客
06-02 4510
python x[:] x[::]用法总结 X[:,0] #　二维数组取第１维所有数据 X[:,1] # 第２列 X[0,:] # 第１行 Ｘ[3,:] # 第三行 Ｘ[1:4,:] # 第一二三行 总结一下： 无论是左边还是右边逗号都要靠近冒号： 如果冒号：的左边或者右边还有冒号，这时候就说明其中一个冒号代表的是范围（eg:1:5 从１到４） 如果冒号：左边或者右边没有任何东西，那么这时候代...
Effective C++ chapter_5
weixin_43599089的博客
09-08 127
5 实现 条款 26 尽可能延后变量定义式出现的时间 ​ 我们写代码的时候，可能会定义一些没有使用的变量，特别是当你过早的定义一个变量，从定义到使用中间如果出现异常且该异常被丢出，那么你就要承担不必要的构造和析构成本。 ​ 所以尽量在你使用到变量的前一刻再定义它。 请记住 : ​ 1. 尽可能延后定义式的出现。这样做可以增加程序的清晰度并改善程序的效率。 条款 27 尽量少做转型动作 ​ C++ 规则的设计目标之一是，保证“类型错误”绝不可能发生。 C++ 提供了四种转型方法 : const_cast 通
Tips for C++ Primer Chapter 5 语句
09-27 89
第5章 语句 switch语句 switch的case标签必须是整型常量表达式。 不允许跨过变量的初始化语句直接跳转到该变量作用域内的另一个位置。 假设运行以下代码时，case匹配了false： case true: 　　string s; //非法；控制流试图绕过一个变量的初始化 　　int i = 0; //非法；控制流试图绕过一个变量的初始化 　　int j;...
C++ primer 5th .Chapter 5 语句 读书笔记
AlexanderGan的博客
01-16 173
C++ primer 5th .Chapter 5 读书笔记 5.1 简单语句 5.2 语句作用域 5.3 条件语句 5.4 迭代语句 5.5 跳转语句 5.6 try语句块和异常处理 5.1 简单语句 表达式语句 ival+5;//无用的表达式语句 空语句 Tips：使用空语句时应当加上注释 复合语句 复合语句是指用花括号括起来的（可能为空的）语句和声明的序列，也被称作块。 Tips：在块中...
Effective C++ chapter_2
weixin_43599089的博客
08-27 158
2 构造/析构/赋值运算 条款 05 了解 C++ 默认编写并调用哪些函数 当没有在类中显示声明，编译器则会声明默认版本的 copy 构造函数、 copy assignment 操作符和一个析构函数。 编译器默认生成的函数是 public 和 inline 的。 class Empty{ }; Empty e1;//default constructor Empty e2(e1);//copy constructor e2 = e1;//copy assignment operator //初始化都
Effective C++ chapter_1
weixin_43599089的博客
08-24 127
1 让自己习惯C++ 条款 01 视 C++ 为一个语言联邦 C : C++以C为基础，block、语句、预处理器、内置数据类型、数组、指针都来自于C。当使用C++中的C成分工作时，没有模板(Template)、没有异常(Exceptions)、没有重载(overloading)。 Object-Oriented C++ : 也就是 C with classes，classes(包括构造函数和析构函数)、封装(encapsulation)、继承(inheritance)、多态(polymorphis
C-PPT-V1.0.rar_文章/文档_C/C++__文章/文档_C/C++_
08-09
在"Chapter 4"和"Chapter 5"中，可能会涵盖数组和字符串。数组是一组相同类型的元素集合，而字符串是字符数组的一种特殊形式。了解数组的动态分配、多维数组，以及字符串处理函数（如strcpy, strcat, strcmp等）对于...
chapter3_code_
10-01
在MATLAB中，初学者首先会接触到基础语法，如变量定义、数据类型（包括标量、向量、矩阵等）、运算符以及控制结构（如for循环和if语句）。这些构成了编程的基础，使用户能对数据进行基本操作和逻辑判断。例如，...
C++程序设计教学课件：CHAPTER 3 FROM C TO C++.ppt
06-03
在"CHAPTER 3 FROM C TO C++"的课件中，讲解了从C语言过渡到C++时关于数据类型、存储分配、运算符、控制执行流程以及预编译器等多个关键知识点。 3.1 数据类型 数据类型是编程中的核心概念，它决定了变量的内存占用...
C++程序设计教学课件：Chapter One From C to C++.ppt
06-03
循环，你可以使用`break`和`continue`语句来控制执行流程。`break`语句用于立即退出当前循环，无论循环条件是否满足。而`continue`语句则用于跳过当前循环体中剩余的部分，直接进入下一次循环的判断。 1.4 C++ 输入...
C++类与对象-基础篇
都市隸人的博客
07-10 1137
本文介绍了类与对象的基础知识，详细介绍了类的定义及使用
C++ 多态
wxk2227814847的博客
07-10 503
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
python-torch加载c++与内核函数
最新发布
weixin_40777649的博客
07-11 175
python 在线加载.cu 文件python 加载.cu 文件方式2二、实现python 在线加载.cu 文件python 加载c++ 方法采用的是torch.utils.cpp_extension包的扩展方法。直接加载cu文件，则采用torch.utils.cpp_extension.load() 方法。"fused",sources=[],具体： fused_bias_act.cpp//scalar_t y;
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【明文导入密钥(C/C++)】
m0_70748845的博客
07-07 402
以明文导入ECC密钥为例。具体的场景介绍及支持的算法规格。
c++__FUNCTION__
06-01
`__FUNCTION__` 是 C++ 中的一个宏定义，用于返回当前函数的名称（字符串类型）。它可以用于调试和日志记录等场景中，方便程序员快速定位代码中的问题。需要注意的是，该宏定义不是标准 C++ 的一部分，但在许多...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值