使用C++#define进行循环与递归展开

最新推荐文章于 2024-07-29 22:24:18 发布
最新推荐文章于 2024-07-29 22:24:18 发布
阅读量2k 收藏 1
点赞数 1
分类专栏： C++语言 文章标签： c++ 宏替换
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ggn_2015/article/details/119902369
版权

前言

在知乎上看到了一篇神奇的文章：

哪段代码最能代表程序员的暴力美学

深感 C++ 宏替换功能前途不可小觑，觉得是时候搞一波事情了（手动滑稽）。

编译器内存超限

最开始的时候，我想写一个解八皇后的程序，过程中先写了一个枚举八个元素全排列的程序：

/// 利用编译器的计算能力来进行常数优化 

#include <iostream>
using namespace std;

int arr[9], vis[9], cnt = 0; /// 用于枚举 全排列 

#define put8(x) if(!vis[x]){vis[x]=1;arr[8]=x;cnt++;vis[x]=0;}
#define set8    put8(1);put8(2);put8(3);put8(4);put8(5);put8(6);put8(7);put8(8);

#define put7(x) if(!vis[x]){vis[x]=1;arr[7]=x;set8;vis[x]=0;}
#define set7    put7(1);put7(2);put7(3);put7(4);put7(5);put7(6);put7(7);put7(8);

#define put6(x) if(!vis[x]){vis[x]=1;arr[6]=x;set7;vis[x]=0;}
#define set6    put6(1);put6(2);put6(3);put6(4);put6(5);put6(6);put6(7);put6(8);

#define put5(x) if(!vis[x]){vis[x]=1;arr[5]=x;set6;vis[x]=0;}
#define set5    put5(1);put5(2);put5(3);put5(4);put5(5);put5(6);put5(7);put5(8);

#define put4(x) if(!vis[x]){vis[x]=1;arr[4]=x;set5;vis[x]=0;}
#define set4    put4(1);put4(2);put4(3);put4(4);put4(5);put4(6);put4(7);put4(8);

#define put3(x) if(!vis[x]){vis[x]=1;arr[3]=x;set4;vis[x]=0;}
#define set3    put3(1);put3(2);put3(3);put3(4);put3(5);put3(6);put3(7);put3(8);

#define put2(x) if(!vis[x]){vis[x]=1;arr[2]=x;set3;vis[x]=0;}
#define set2    put2(1);put2(2);put2(3);put2(4);put2(5);put2(6);put2(7);put2(8); /// 尝试所有可能 

#define put1(x) if(!vis[x]){vis[x]=1;arr[1]=x;set2;vis[x]=0;}
#define set1    put1(1);put1(2);put1(3);put1(4);put1(5);put1(6);put1(7);put1(8);

int main() {
	set1;
	cout << cnt << endl;
	return 0; 
}

我用 g++ define.cpp -o define 命令，将这个文件在 ubuntu 20.04 系统下进行了编译，经过了长达十几分钟的艰苦奋战（电脑内存占用几乎时时刻刻都是 95% 以上），编译器终于缴械投降了。

define.cpp: In function ‘int main()’:
define.cpp:8:26: internal compiler error: Segmentation fault
    8 | #define put8(x) if(!vis[x]){vis[x]=1;arr[8]=x;cnt++;vis[x]=0;}
      |                          ^
define.cpp:9:33: note: in expansion of macro ‘put8’
    9 | #define set8    put8(1);put8(2);put8(3);put8(4);put8(5);put8(6);put8(7);put8(8);
      |                                 ^~~~
define.cpp:11:47: note: in expansion of macro ‘set8’
   11 | #define put7(x) if(!vis[x]){vis[x]=1;arr[7]=x;set8;vis[x]=0;}
      |                                               ^~~~
define.cpp:12:25: note: in expansion of macro ‘put7’
   12 | #define set7    put7(1);put7(2);put7(3);put7(4);put7(5);put7(6);put7(7);put7(8);
      |                         ^~~~
define.cpp:14:47: note: in expansion of macro ‘set7’
   14 | #define put6(x) if(!vis[x]){vis[x]=1;arr[6]=x;set7;vis[x]=0;}
      |                                               ^~~~
define.cpp:15:25: note: in expansion of macro ‘put6’
   15 | #define set6    put6(1);put6(2);put6(3);put6(4);put6(5);put6(6);put6(7);put6(8);
      |                         ^~~~
define.cpp:17:47: note: in expansion of macro ‘set6’
   17 | #define put5(x) if(!vis[x]){vis[x]=1;arr[5]=x;set6;vis[x]=0;}
      |                                               ^~~~
define.cpp:18:49: note: in expansion of macro ‘put5’
   18 | #define set5    put5(1);put5(2);put5(3);put5(4);put5(5);put5(6);put5(7);put5(8);
      |                                                 ^~~~
define.cpp:20:47: note: in expansion of macro ‘set5’
   20 | #define put4(x) if(!vis[x]){vis[x]=1;arr[4]=x;set5;vis[x]=0;}
      |                                               ^~~~
define.cpp:21:17: note: in expansion of macro ‘put4’
   21 | #define set4    put4(1);put4(2);put4(3);put4(4);put4(5);put4(6);put4(7);put4(8);
      |                 ^~~~
define.cpp:23:47: note: in expansion of macro ‘set4’
   23 | #define put3(x) if(!vis[x]){vis[x]=1;arr[3]=x;set4;vis[x]=0;}
      |                                               ^~~~
define.cpp:24:41: note: in expansion of macro ‘put3’
   24 | #define set3    put3(1);put3(2);put3(3);put3(4);put3(5);put3(6);put3(7);put3(8);
      |                                         ^~~~
define.cpp:26:47: note: in expansion of macro ‘set3’
   26 | #define put2(x) if(!vis[x]){vis[x]=1;arr[2]=x;set3;vis[x]=0;}
      |                                               ^~~~
define.cpp:27:41: note: in expansion of macro ‘put2’
   27 | #define set2    put2(1);put2(2);put2(3);put2(4);put2(5);put2(6);put2(7);put2(8); /// ���������
      |                                         ^~~~
define.cpp:29:47: note: in expansion of macro ‘set2’
   29 | #define put1(x) if(!vis[x]){vis[x]=1;arr[1]=x;set2;vis[x]=0;}
      |                                               ^~~~
define.cpp:30:25: note: in expansion of macro ‘put1’
   30 | #define set1    put1(1);put1(2);put1(3);put1(4);put1(5);put1(6);put1(7);put1(8);
      |                         ^~~~
define.cpp:33:2: note: in expansion of macro ‘set1’
   33 |  set1;
      |  ^~~~
mmap: Cannot allocate memory
Please submit a full bug report,
with preprocessed source if appropriate.
See <file:///usr/share/doc/gcc-9/README.Bugs> for instructions.

场面一度十分尴尬。后来我试了试 n < 8 n < 8 n<8 的情况，最后终于成功的计算出了 n = 6 n = 6 n=6 的情况下的全排列。

/// 利用编译器的计算能力来进行常数优化 

#include <iostream>
using namespace std;

int arr[9], vis[9], cnt = 0; /// 用于枚举 全排列 


#define put6(x) if(!vis[x]){vis[x]=1;arr[6]=x;cnt++;vis[x]=0;}
#define set6    put6(1);put6(2);put6(3);put6(4);put6(5);put6(6);

#define put5(x) if(!vis[x]){vis[x]=1;arr[5]=x;set6;vis[x]=0;}
#define set5    put5(1);put5(2);put5(3);put5(4);put5(5);put5(6);

#define put4(x) if(!vis[x]){vis[x]=1;arr[4]=x;set5;vis[x]=0;}
#define set4    put4(1);put4(2);put4(3);put4(4);put4(5);put4(6);

#define put3(x) if(!vis[x]){vis[x]=1;arr[3]=x;set4;vis[x]=0;}
#define set3    put3(1);put3(2);put3(3);put3(4);put3(5);put3(6);

#define put2(x) if(!vis[x]){vis[x]=1;arr[2]=x;set3;vis[x]=0;}
#define set2    put2(1);put2(2);put2(3);put2(4);put2(5);put2(6); /// 尝试所有可能 

#define put1(x) if(!vis[x]){vis[x]=1;arr[1]=x;set2;vis[x]=0;}
#define set1    put1(1);put1(2);put1(3);put1(4);put1(5);put1(6);

int main() {
	set1;
	cout << cnt << endl;
	return 0; 
}

总之还是编译了十多秒。

改名

标识符的名字短点的话是否能让编辑过程消耗的内存少一些呢？

/// 利用编译器的计算能力来进行常数优化 

#include <iostream>
using namespace std;

#define vis v
#define arr a

int arr[9], vis[9], cnt = 0; /// 用于枚举 全排列 
inline void D(int x) {vis[x] = 0;}
inline void V(int x) {vis[x] = 1;}
inline void C() {cnt ++;}
inline void A(int id, int x) {arr[id] = x;}

#define P8(x) if(!vis[x]){V(x);A(8,x);C();D(x);}
#define S8    P8(1);P8(2);P8(3);P8(4);P8(5);P8(6);P8(7);P8(8);

#define P7(x) if(!vis[x]){V(x);A(7,x);S8;D(x);}
#define S7    P7(1);P7(2);P7(3);P7(4);P7(5);P7(6);P7(7);P7(8);

#define P6(x) if(!vis[x]){V(x);A(6,x);S7;D(x);}
#define S6    P6(1);P6(2);P6(3);P6(4);P6(5);P6(6);P6(7);P6(8);

#define P5(x) if(!vis[x]){V(x);A(5,x);S6;D(x);}
#define S5    P5(1);P5(2);P5(3);P5(4);P5(5);P5(6);P5(7);P5(8);

#define P4(x) if(!vis[x]){V(x);A(4,x);S5;D(x);}
#define S4    P4(1);P4(2);P4(3);P4(4);P4(5);P4(6);P4(7);P4(8);

#define P3(x) if(!vis[x]){V(x);A(3,x);S4;D(x);}
#define S3    P3(1);P3(2);P3(3);P3(4);P3(5);P3(6);P3(7);P3(8);

#define P2(x) if(!vis[x]){V(x);A(2,x);S3;D(x);}
#define S2    P2(1);P2(2);P2(3);P2(4);P2(5);P2(6);P2(7);P2(8); /// 尝试所有可能 

#define P1(x) if(!vis[x]){V(x);A(1,x);S2;D(x);}
#define S1    P1(1);P1(2);P1(3);P1(4);P1(5);P1(6);P1(7);P1(8);

int main() {
	S1;
	cout << cnt << endl;
	return 0; 
}

很不幸的是，编译最终还是因为内存不足而失败了。

测试最大展开

#include <cstdio>

int cnt = 0;
inline void P(int i) {
	cnt ++;
}

#define D1(i) P(i);
#define D2(i) D1(i);D1(i+1);
#define D4(i) D2(i);D2(i+2);
#define D8(i) D4(i);D4(i+4);
#define DA(i) D8(i);D8(i+8);  /// DA: D16
#define DB(i) DA(i);DA(i+16); /// DB: D32
#define DC(i) DB(i);DB(i+32); /// DC: D64
#define DD(i) DC(i);DC(i+64); /// DD: D128
#define DE(i) DD(i);DD(i+128); /// DE: D256
#define DF(i) DE(i);DE(i+256); /// DF: D512
#define DG(i) DF(i);DF(i+512); /// DG: D1024
#define DH(i) DG(i);DG(i+1024); /// DH: D2048
#define DI(i) DH(i);DH(i+2048); /// DI: D4096
#define DJ(i) DI(i);DI(i+4096); /// DJ: D8192
#define DK(i) DJ(i);DJ(i+8192); /// DK: D16384
#define DL(i) DK(i);DK(i+16384); /// DL: D32768
#define DM(i) DL(i);DL(i+32768); /// DM: D65536
#define DN(i) DM(i);DM(i+65536); /// DN: D131072
#define DO(i) DN(i);DN(i+131072); /// DO: D262144

int main() {
	DN(0); ///DO(0); 会导致编译器崩溃 
	printf("%d\n", cnt);
	return 0;
}

在我的电脑上，上述程序能够成功展开至 131072 131072 131072，但是当展开至 262144 262144 262144 时，编译因内存不足失败。

因此可以借助这个程序进行 1 ∼ n    ( n ≤ 131072 ) 1\sim n\;(n\leq 131072) 1∼n(n≤131072) 的循环展开。

#include <cstdio>

int cnt = 0;
inline void P(int i) {
	cnt ++;
}

#define D1(i) P(i);
#define D2(i) D1(i);if(i+1<=n){D1(i+1);}
#define D4(i) D2(i);if(i+2<=n){D2(i+2);}
#define D8(i) D4(i);if(i+4<=n){D4(i+4);}
#define DA(i) D8(i);if(i+8<=n){D8(i+8);}  /// DA: D16
#define DB(i) DA(i);if(i+16<=n){DA(i+16);} /// DB: D32
#define DC(i) DB(i);if(i+32<=n){DB(i+32);} /// DC: D64
#define DD(i) DC(i);if(i+64<=n){DC(i+64);} /// DD: D128
#define DE(i) DD(i);if(i+128<=n){DD(i+128);} /// DE: D256
#define DF(i) DE(i);if(i+256<=n){DE(i+256);} /// DF: D512
#define DG(i) DF(i);if(i+512<=n){DF(i+512);} /// DG: D1024
#define DH(i) DG(i);if(i+1024<=n){DG(i+1024);} /// DH: D2048
#define DI(i) DH(i);if(i+2048<=n){DH(i+2048);} /// DI: D4096
#define DJ(i) DI(i);if(i+4096<=n){DI(i+4096);} /// DJ: D8192
#define DK(i) DJ(i);if(i+8192<=n){DJ(i+8192);} /// DK: D16384
#define DL(i) DK(i);if(i+16384<=n){DK(i+16384);} /// DL: D32768
#define DM(i) DL(i);if(i+32768<=n){DL(i+32768);} /// DM: D65536
#define DN(i) DM(i);if(i+65536<=n){DM(i+65536);} /// DN: D131072
#define DO(i) DN(i);if(i+131072<=n){DN(i+131072);} /// DO: D262144

int main() {
	int n = 1000;
	DN(0); ///DO(0); 会导致编译器崩溃 
	printf("%d\n", cnt);
	return 0;
}

经过了 20 20 20 多秒的漫长编译，上述程序得出了正确的计算结果 1001 1001 1001。

循环展开实践

输入 n n n 个数，输出这 n n n 个数的和。

#include <cstdio>

int cnt = 0, A[10001];
inline void input(int i) {
	scanf("%d", &A[i]);
}
inline void sum(int i) {
	cnt += A[i];
}

#define D1(i) P(i);
#define D2(i) D1(i);if(i+1<=n){D1(i+1);}
#define D4(i) D2(i);if(i+2<=n){D2(i+2);}
#define D8(i) D4(i);if(i+4<=n){D4(i+4);}
#define DA(i) D8(i);if(i+8<=n){D8(i+8);}  /// DA: D16
#define DB(i) DA(i);if(i+16<=n){DA(i+16);} /// DB: D32
#define DC(i) DB(i);if(i+32<=n){DB(i+32);} /// DC: D64
#define DD(i) DC(i);if(i+64<=n){DC(i+64);} /// DD: D128
#define DE(i) DD(i);if(i+128<=n){DD(i+128);} /// DE: D256
#define DF(i) DE(i);if(i+256<=n){DE(i+256);} /// DF: D512
#define DG(i) DF(i);if(i+512<=n){DF(i+512);} /// DG: D1024
#define DH(i) DG(i);if(i+1024<=n){DG(i+1024);} /// DH: D2048
#define DI(i) DH(i);if(i+2048<=n){DH(i+2048);} /// DI: D4096
#define DJ(i) DI(i);if(i+4096<=n){DI(i+4096);} /// DJ: D8192
#define DK(i) DJ(i);if(i+8192<=n){DJ(i+8192);} /// DK: D16384
#define DL(i) DK(i);if(i+16384<=n){DK(i+16384);} /// DL: D32768
#define DM(i) DL(i);if(i+32768<=n){DL(i+32768);} /// DM: D65536
#define DN(i) DM(i);if(i+65536<=n){DM(i+65536);} /// DN: D131072
#define DO(i) DN(i);if(i+131072<=n){DN(i+131072);} /// DO: D262144

int main() {
	int n; scanf("%d", &n);
	#define P input
	DK(1); ///DO(0); 会导致编译器崩溃 
	#undef P
	#define P sum
	DK(1);
	#undef P
	printf("%d\n", cnt);
	return 0;
}

程序可以通过编译并得出正确的结果。

无循环冒泡排序

光是想一想就觉得很爽。

#include <cstdio>

#define D1(i) P(i);
#define D2(i) D1(i);if(i+1<=n){D1(i+1);}
#define D4(i) D2(i);if(i+2<=n){D2(i+2);}
#define D8(i) D4(i);if(i+4<=n){D4(i+4);}
#define DA(i) D8(i);if(i+8<=n){D8(i+8);}  /// DA: D16
#define DB(i) DA(i);if(i+16<=n){DA(i+16);} /// DB: D32
#define DC(i) DB(i);if(i+32<=n){DB(i+32);} /// DC: D64
#define DD(i) DC(i);if(i+64<=n){DC(i+64);} /// DD: D128
#define DE(i) DD(i);if(i+128<=n){DD(i+128);} /// DE: D256
#define DF(i) DE(i);if(i+256<=n){DE(i+256);} /// DF: D512
#define DG(i) DF(i);if(i+512<=n){DF(i+512);} /// DG: D1024
#define DH(i) DG(i);if(i+1024<=n){DG(i+1024);} /// DH: D2048
#define DI(i) DH(i);if(i+2048<=n){DH(i+2048);} /// DI: D4096
#define DJ(i) DI(i);if(i+4096<=n){DI(i+4096);} /// DJ: D8192
#define DK(i) DJ(i);if(i+8192<=n){DJ(i+8192);} /// DK: D16384
#define DL(i) DK(i);if(i+16384<=n){DK(i+16384);} /// DL: D32768
#define DM(i) DL(i);if(i+32768<=n){DL(i+32768);} /// DM: D65536
#define DN(i) DM(i);if(i+65536<=n){DM(i+65536);} /// DN: D131072
#define DO(i) DN(i);if(i+131072<=n){DN(i+131072);} /// DO: D262144

#define LOOP(i) for(int t=i;t<=n;t+=1024){DG(t);} /// 实现循环展开 

int n;

int cnt = 0, A[10001];

inline void input(int i) {
	scanf("%d", &A[i]);
}
void put(int x) {
	if(x > 9) put(x/10);
	putchar('0' + x%10);
}
inline void output(int i) {
	put(A[i]); putchar(' '); /// 输出优化 
}

void nxt(int i) {
	if(A[i-1] > A[i]) {int t = A[i-1]; A[i-1] = A[i]; A[i] = t;}
}

void line(int i) { /// 进行一轮冒泡 
	#define P nxt
	LOOP(2);
	#undef P
}

int main() {
	scanf("%d", &n);
	#define P input /// 输入数据 
	LOOP(1);
	#undef P
	#define P line /// 冒泡 
	LOOP(1);
	#undef P
	#define P output /// 输出 
	LOOP(1);
	#undef P
	return 0;
}

洛谷 U165361 bubble-sort 冒泡排序测试处

GGN_2015
关注
专栏目录
【C/C++ 性能优化】循环展开在C++中的艺术：提升性能的策略与实践
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
02-12 1757
在讨论C++中循环展开的具体实现之前，了解其背后的动机和基本概念是非常重要的。循环展开，作为一种优化技术，主要用于减少程序中循环的开销，从而提高程序的执行效率。本章将深入探讨循环展开的动机、好处以及可能的缺点。
c++模板元编程三：循环展开
Dean Chen的专栏
04-05 6466
2.2 loop unrolling 循环展开前面enum一节介绍的是和template联合，引发编译器递归的奇妙作用。template本身无需enum配合也可以达到递归的效果。// test template recursive for loop unrolling cout << "test 2: template recursive for loop unrolling" << en
循环展开c++
jerry的博客
04-01 1287
#pragma UNROLL 4 被用来做循环展开，下面是一个实例： #include "time.h" #include <stdio.h> #include<iostream> #include<Windows.h> using namespace std; int main() { clock_t start_time, end_time; start_time = clock(); //获取开始执行时间 #pragma unroll 10
关于#define的使用方法总结
最新发布
dearzhangxp的博客
07-29 1241
#define 是 C 和 C++ 编程语言中的预处理指令，用于定义宏（macro）。宏是一种预处理器功能，它允许程序员定义一个标识符（通常是大写字母），该标识符可以被替换为一段代码、表达式或常量值。，#define定义有参函数宏时要注意参数的运算优先级，一定要加括号保护参数
C++性能剖析教程之循环展开
01-21
什么是循环展开？ 循环展开，英文中称Loop unwinding或loop unrolling，是一种牺牲程序的尺寸来加快程序的执行速度的优化方法。可以由程序员完成，也可由编译器自动优化完成。循环展开最常用来降低循环开销，为具有多个功能单元的处理器提供指令级并行。也有利于指令流水线的调度。 循环展开能从两方面改进程序的性能： 减少了不直接有助于程序结果的操作的数量，例如循环索引计算和分支条件。 提供了一些方法，可以进一步变化代码，减少整个计算中关键路径上的操作数量。 循环展开对程序性能的影响 我们直接以实际代码向大家展示循环展开的作用，首先看未经过循环展开优化的代码： #includ
c++宏编程一览
CDScan的专栏
11-24 5493
 基础部分 1. __VA_ARGS__: 用来替换任意参数部分, 相当于c语言中的va_list;  例:#define OUT(...)    printf(__VA_ARGS__) 2. 宏从内向外展开(例外情况见4)原因是, 当一个红的参数也是宏的时候, 它会尝试先展开它的参数;  例:max(max(1, 3), 2) => max(3, 2) => 3
循环展开实现实例
12-20
完整实现了计算机体系结构中的循环展开，包括迭代复制、寄存器重命名、调度等
【C++】内联函数(inline)和宏定义(# define)的优劣及其区别
Y先森0.0
09-29 1027
一.宏定义:# define 1.为什么要使用宏？因为调用宏比调用函数更有效率，函数的调用必须要将程序的执行顺序转移到函数所存放的内存地址中，将函数程序内容执行完后，再返回到执行该函数前的地方，这种转移操作要求执行前要保存现场并记忆执行地址，转回后要恢复现场，并按原来保存的地址继续执行，因此，函数调用有一定的时间和空间的开销，而宏只是在预处理的地方把代码展开，不需要额外的时间和空间开销，...
c++知识理解（#define, 堆/栈内存，static, const关键字，引用与指针，多态）
weixin_38730718的博客
04-21 451
1、宏定义 宏定义命令 #define ， 1）不带参数的宏定义 格式：#define 标识符 字符串，其中标识符即为宏名。 作用：在预编译阶段进行宏展开，将宏名替换为定义的字符串。不做语法检查。 说明：a.宏名一般大写，末尾无分号 b.宏定义不分配内存，变量定义分配内存 c. 宏定义只对标识符进行替换，不会将包含标识符的字符串进行替换...
C++算法程序整理——递归算法
sunqin的博客
02-08 2770
递归算法 递归，定义一个过程或函数时出现调用本过程或本函数的成分，称之为递归。 一般来说，能够用递归解决的问题应该满足以下三个条件： 1）需要解决的问题可以转化为一个或多个同构（或同样性质的）子问题来求解，而这些子问题的求解方法与原问题完全相同，只是在数量规模上不同。 2）递归调用的次数必须是有限的。 3）必须有结束递归的条件来终止递归。 ...
#define 的语法
07-01
#define 是预处理指令，在C/C++语言中...3. 避免在循环或条件语句中直接使用宏，这可能导致无限递归或难以调试的问题。 4. C++11引入了`#define`的替代方案`#pragma once`和`const`, 这些提供了更强的控制和类型安全。
用宏实现的递归式循环
12-23
用宏实现的递归式循环 用宏实现的递归式循环
const, static， inline, #define的用法以及关系
linpengbin的专栏
06-04 2181
在我们写代码的过程中，添加合适恰当的相应修饰符去告诉编译器该怎么做，限制编译器在我们背后偷偷的做一些出乎我们意料的行为，这样方能提高程序的鲁棒性。作为程序员，我们是主宰，应该由我们来明确告诉编译器，我们希望它做什么，不希望它做什么，而不是等发生错误的时候才花大量的时间去debug。合理应用各种修饰符，就像我们为程序开凿了一条河床，让它按照我们的意愿流淌，何乐而不为？语言有很多修饰符，我们在这里只分析
C++宏完美实现For Each(数据类型 变量 In 集合)... Next循环(含倒序、支持嵌套)
weixin_55465758的博客
03-12 729
/宏不能自动判断变量类型，故仅需一步，人工给定数据类型即可(decltype、typeof是C++扩展，auto是新标准，并非适用于所有C/C++编译器)。C/C++宏完美实现For Each ... Next循环(含倒序、支持嵌套),多余";"、"{"、"}"进献给C++；//我就喜欢匈牙利命名法，就喜欢匈牙利命名法。看着就是顺眼，顺眼！//我就喜欢匈牙利命名法，就喜欢匈牙利命名法。//嵌套中同名变量Item按局部变量处理，逻辑上也是如此，尽管不建议如此操作。//精彩绝伦的"特殊改进版"
C++用模板元编程进行循环展开的性能测试
weixin_33889665的博客
12-20 741
在网上看到一篇C++模板元编程的文章，里面提到可以用来做循环展开，文章地址如下：https://www.2cto.com/kf/20120...然后在VS2015里测了一下，测试代码如下： template <int dim> int get_sum(int* a) { return a[0] + get_sum&l...
C/C++用宏定义简化for循环
Otto的学习笔记
10-24 1953
记录一下for循环简化 #define _for(i,a,b) for( int i=(a); i<(b); ++i) 这样 for(int i=0;i<10;i++) 就简化为了 _for(i, 0, 10)
元编程：循环展开
qq_38409301的博客
12-27 204
转载：c++模板元编程三：循环展开_Dean Chen的专栏-CSDN博客_c++循环展开 重点： 总结： 元编程就是在编译期间搞事情。这里利用了static 函数搞事情。如图，static静态变量，开辟一块内存。data段一开始就存储了这些信息。而static信息会在编译阶段就进行处理。 ...
让编译器展开循环
qq_27453443的博客
03-23 828
编译器可以很容易地执行循环展开。 只要优化级别设置的足够高，许多编译器都能例行公事地做到这一点。用命令行选项'-funroll-loops'调用GCC，会执行循环展开 摘自《深入理解计算机系统》第三版
C++性能优化系列——3D高斯核卷积计算(四)Intrinsic实现一维卷积与循环展开
yan31415的博客
09-17 834
基于 性能优化系列(CPU)——3D高斯核卷积计算(三)FMA向量化计算一维卷积 中实现，本文用Intrinsic实现向量化的一维卷积计算。 代码实现 void Conv1D_Ins_Cmb(float* pSrcLine, int iLength, float* pKernel, int kernelSize, float* pDst,float* pSimdKernel) { int iConvSize = iLength - kernelSize + 1; float* pDstTemp
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值