#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; //为数组buffer的i位赋值i
}
size_t max_value = buffer[0];
for(size_t i = 0; i < buffer_count; ++i) //处理该语句花费了更多时间
{
//下面这条语句执行了buffer_count次
max_value = (max_value > buffer[i]) ? max_value : buffer[i];
}
std::cout << max_value << '\n'; //buffer_count是多少,该语句就输出多少
}
#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];
for(size_t i = 0; i < buffer_count; i += 8) //语句i < buffer_count;和语句i += 8;都处理了1250次,程序在循环的维护上占用了较少的资源
{
//在处理的逻辑上占用了较多的资源
max_value = (max_value > buffer[i]) ? max_value : buffer[i];
max_value = (max_value > buffer[i+1]) ? max_value : buffer[i+1];
max_value = (max_value > buffer[i+2]) ? max_value : buffer[i+2];
max_value = (max_value > buffer[i+3]) ? max_value : buffer[i+3];
max_value = (max_value > buffer[i+4]) ? max_value : buffer[i+4];
max_value = (max_value > buffer[i+5]) ? max_value : buffer[i+5];
max_value = (max_value > buffer[i+6]) ? max_value : buffer[i+6];
max_value = (max_value > buffer[i+7]) ? max_value : buffer[i+7];
}
std::cout << max_value << '\n'; //输出了预期的值
}
#include<iostream>
#include<vector>
int main(void)
{
constexpr size_t buffer_count = 10001; //注意这里的值是10001
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];
//0~7,8~15,16~23...循环的倒数第二次处理的是9992~9999,此时i=9992
//(8*0)~(8*1-1),(8*1)~(8*2-1),(8*2)~(8*3-1)...循环的倒数第二次处理的是(8*1249)~(8*1250-1)即9992~9999,此时i=9992
for(size_t i = 0; i < buffer_count; i += 8) //当i=9992时,表达式i += 8的求值结果是i=10000,符合循环条件,继续执行循环体
{
max_value = (max_value > buffer[i]) ? max_value : buffer[i]; //buffer[10000] = 10000,符合预期
max_value = (max_value > buffer[i+1]) ? max_value : buffer[i+1]; //但buffer[10001] = ?,内存访问越界
max_value = (max_value > buffer[i+2]) ? max_value : buffer[i+2]; //但buffer[10002] = ?,内存访问越界
max_value = (max_value > buffer[i+3]) ? max_value : buffer[i+3]; //但buffer[10003] = ?,内存访问越界
max_value = (max_value > buffer[i+4]) ? max_value : buffer[i+4]; //但buffer[10004] = ?,内存访问越界
max_value = (max_value > buffer[i+5]) ? max_value : buffer[i+5]; //但buffer[10005] = ?,内存访问越界
max_value = (max_value > buffer[i+6]) ? max_value : buffer[i+6]; //但buffer[10006] = ?,内存访问越界
max_value = (max_value > buffer[i+7]) ? max_value : buffer[i+7]; //但buffer[10007] = ?,内存访问越界
}
std::cout << max_value << '\n';
}
#include<iostream>
#include<vector>
int main(void)
{
constexpr size_t buffer_count = 10001; //注意这里的值是10001
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];
for(size_t i = 0; i + 8 < buffer_count; i += 8) //注意i + 8 < buffer_count;当执行完第1249次时,i=9992,i += 8;使得i=10000,再用这个值带入i + 8 < buffer_count; 10000+8<buffer_count,循环结束
{
max_value = (max_value > buffer[i]) ? max_value : buffer[i];
max_value = (max_value > buffer[i+1]) ? max_value : buffer[i+1];
max_value = (max_value > buffer[i+2]) ? max_value : buffer[i+2];
max_value = (max_value > buffer[i+3]) ? max_value : buffer[i+3];
max_value = (max_value > buffer[i+4]) ? max_value : buffer[i+4];
max_value = (max_value > buffer[i+5]) ? max_value : buffer[i+5];
max_value = (max_value > buffer[i+6]) ? max_value : buffer[i+6];
max_value = (max_value > buffer[i+7]) ? max_value : buffer[i+7];
}
for(size_t i = buffer_count/8*8; i < buffer_count; ++i) //同样的逻辑写了两遍,可以简化
//10001/8=1250(整型的除法),1250*8=10000
{
max_value = (max_value > buffer[i]) ? max_value : buffer[i];
}
std::cout << max_value << '\n'; //OK
}
#include<iostream>
#include<vector>
int main(void)
{
constexpr size_t buffer_count = 10001;
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();
for(size_t i = 0; i + 8 < buffer_count; i += 8) //第一个循环仍然处理的是可以整除的部分
{
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) //第一个循环仍然处理的是不能整除的部分,最多包含7个元素
{
max_value = (max_value > buffer[i]) ? max_value : buffer[i];
}*/
switch(buffer_count % 8) //使用switch语句处理不能整除的部分
{
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; //最后一句不能加[[fallthrough]];
};
std::cout << max_value << '\n'; //OK
}
#include<iostream>
#include<vector>
int main(void)
{
constexpr size_t buffer_count = 10001;
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,仍然执行switch语句: 访问越界!
{
case 0 : max_value = (max_value > *ptr) ? max_value : *ptr; ++ptr;[[fallthrough]]; //如果数组元素个数能被8整除,则落在case 0
case 7 : max_value = (max_value > *ptr) ? max_value : *ptr; ++ptr;[[fallthrough]]; //如果数组元素个数除以8余7,则落在case 7
case 6 : max_value = (max_value > *ptr) ? max_value : *ptr; ++ptr;[[fallthrough]]; //如果数组元素个数除以8余6,则落在case 6
case 5 : max_value = (max_value > *ptr) ? max_value : *ptr; ++ptr;[[fallthrough]]; //如果数组元素个数除以8余5,则落在case 5
case 4 : max_value = (max_value > *ptr) ? max_value : *ptr; ++ptr;[[fallthrough]]; //如果数组元素个数除以8余4,则落在case 4
case 3 : max_value = (max_value > *ptr) ? max_value : *ptr; ++ptr;[[fallthrough]]; //如果数组元素个数除以8余3,则落在case 3
case 2 : max_value = (max_value > *ptr) ? max_value : *ptr; ++ptr;[[fallthrough]]; //如果数组元素个数除以8余2,则落在case 2
case 1 : max_value = (max_value > *ptr) ? max_value : *ptr; ++ptr; //如果数组元素个数除以8余1,则落在case 1
};
//假设buffer_count=24->(buffer_count - 1) / 8 =2,循环执行2次
//假设buffer_count=31->(buffer_count - 1) / 8 =3,循环执行3次
for(size_t i = 0; i < (buffer_count - 1) / 8; ++i) //注意循环条件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;
}
//switch语句和for语句包含“相同”的逻辑,还可以简化
std::cout << max_value << '\n'; //OK
}
下面就是达夫设备的框架
#include<iostream>
#include<vector>
int main(void)
{
constexpr size_t buffer_count = 10001;
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) //达夫设备: switch语句中嵌套了一个循环语句。switch语句后可以跟任何语句,参考cppreference相关文档
//#1先执行buffer_count % 8,根据求得的结果跳转到对应的case
for(; i < (buffer_count + 7) / 8; ++i) //注意条件表达式i < (buffer_count + 7) / 8,把丢失的那一部分找回来
{
[[fallthrough]]; //可以避免系统报错this statement may fall through
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;
}//#1处的执行走到这里的时候会执行for循环里面的迭代表达式(++i)和条件表达式(i < (buffer_count + 7) / 8),开始循环
std::cout << max_value << '\n'; //OK
}
参考
深蓝学院:C++基础与深度解析