z****e
发帖数: 2024 | 1 要8个变量，都遍历一遍，每个从 1 to 4, need 4^8= 65536.
i need to define i1,i2,i3,...i8, then start 8 nested "for" loops.
is there any way i can do this more easily?
btw, the question is all about c++ syntax, and C++ programming technique,
language features.
Nothing about why i need to do this and how to improve this mathematically
is irrelevant.
Thanks 大牛们。
早谢了。 | X****r
发帖数: 3557 | 2 for (int i = 0; i < 65536; i++) {
int i1 = (i & 3) + 1；
int i2 = ((i >> 2) & 3) + 1;
int i3 = ((i >> 4) & 3) + 1;
int i4 = ((i >> 6) & 3) + 1;
int i5 = ((i >> 8) & 3) + 1;
int i6 = ((i >> 10) & 3) + 1;
int i7 = ((i >> 12) & 3) + 1;
int i8 = ((i >> 14) & 3) + 1;
// ...
}
technique,
mathematically
【在 z****e 的大作中提到】
: 要8个变量，都遍历一遍，每个从 1 to 4, need 4^8= 65536.
: i need to define i1,i2,i3,...i8, then start 8 nested "for" loops.
: is there any way i can do this more easily?
: btw, the question is all about c++ syntax, and C++ programming technique,
: language features.
: Nothing about why i need to do this and how to improve this mathematically
: is irrelevant.
: Thanks 大牛们。
: 早谢了。
| X****r
发帖数: 3557 | 3 一个更通用的方法：
int i[8] = {1, 1, 1, 1, 1, 1, 1, 1}
int k;
do {
// do your stuff with i[0] to i[7]
for (k = 0; k < 8 && ++i[k] > 4; i[k++] = 1);
} while (k < 8);
technique,
mathematically
【在 z****e 的大作中提到】
: 要8个变量，都遍历一遍，每个从 1 to 4, need 4^8= 65536.
: i need to define i1,i2,i3,...i8, then start 8 nested "for" loops.
: is there any way i can do this more easily?
: btw, the question is all about c++ syntax, and C++ programming technique,
: language features.
: Nothing about why i need to do this and how to improve this mathematically
: is irrelevant.
: Thanks 大牛们。
: 早谢了。
| z****e
发帖数: 2024 | 4 这看得我惊呆了。
有没有什么模板的方法，可以好多重循环，任意重的，可能不？
你这个通用的，和上面那个，我要好好理解一下，目前还消化不了。
【在 X****r 的大作中提到】
: 一个更通用的方法：
: int i[8] = {1, 1, 1, 1, 1, 1, 1, 1}
: int k;
: do {
: // do your stuff with i[0] to i[7]
: for (k = 0; k < 8 && ++i[k] > 4; i[k++] = 1);
: } while (k < 8);
:
: technique,
: mathematically
| X****r
发帖数: 3557 | 5 任意重的当然可以用这个方法，要不然怎么说更通用呢：
void multi_loop(int *from, int *to, int n,
void (*callback)(const int *, int)) {
int *i = new int[n];
int k;
for (k = 0; k < n; k++) {
i[k] = from[k];
}
do {
(*callback)(i, n);
for (k = 0; k < n && ++i[k] > to[k]; k++) {
i[k] = from[k];
}
} while (k < n);
delete[] i;
}
【在 z****e 的大作中提到】
: 这看得我惊呆了。
: 有没有什么模板的方法，可以好多重循环，任意重的，可能不？
: 你这个通用的，和上面那个，我要好好理解一下，目前还消化不了。
| t****t
发帖数: 6806 | 6 make it template:
template
void multi_loop(const T* from, const T* to, int n, F f)
{
T* i=new T[n];
std::copy(from, from+n, i);
int k;
do {
f(i);
for (k = 0; k < n && ++i[k] > to[k]; i[k] = from[k], k++);
while (k
delete [] i;
}
【在 X****r 的大作中提到】
: 任意重的当然可以用这个方法，要不然怎么说更通用呢：
: void multi_loop(int *from, int *to, int n,
: void (*callback)(const int *, int)) {
: int *i = new int[n];
: int k;
: for (k = 0; k < n; k++) {
: i[k] = from[k];
: }
: do {
: (*callback)(i, n);
| t****t
发帖数: 6806 | 7 (shouldn't use i[k++]=from[k] as it's undefined...)
【在 X****r 的大作中提到】
: 任意重的当然可以用这个方法，要不然怎么说更通用呢：
: void multi_loop(int *from, int *to, int n,
: void (*callback)(const int *, int)) {
: int *i = new int[n];
: int k;
: for (k = 0; k < n; k++) {
: i[k] = from[k];
: }
: do {
: (*callback)(i, n);
| X****r
发帖数: 3557 | 8 你说得对，抄下来的时候没看。
这样的话i[k] = from[k]放到for循环内部，
留k++作为for循环的第三个表达式好看一些。
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
| b******u
发帖数: 469 | 9 orz.
【在 X****r 的大作中提到】
: 一个更通用的方法：
: int i[8] = {1, 1, 1, 1, 1, 1, 1, 1}
: int k;
: do {
: // do your stuff with i[0] to i[7]
: for (k = 0; k < 8 && ++i[k] > 4; i[k++] = 1);
: } while (k < 8);
:
: technique,
: mathematically
| a**u
发帖数: 813 | 10 using recursive functions to do it.
【在 z****e 的大作中提到】
: 要8个变量，都遍历一遍，每个从 1 to 4, need 4^8= 65536.
: i need to define i1,i2,i3,...i8, then start 8 nested "for" loops.
: is there any way i can do this more easily?
: btw, the question is all about c++ syntax, and C++ programming technique,
: language features.
: Nothing about why i need to do this and how to improve this mathematically
: is irrelevant.
: Thanks 大牛们。
: 早谢了。
| | | z****e
发帖数: 2024 | 11 发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
墙呢，你在哪？ | z****e
发帖数: 2024 | 12 发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
墙呢，你在哪？ | z****e
发帖数: 2024 | 13 句弱智疑问，
from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
我真要撞墙了，这么多解法，我就真是一个都没有理解。
原来还以为自己C++已经有感觉了呢。
【在 t****t 的大作中提到】
: make it template:
: template
: void multi_loop(const T* from, const T* to, int n, F f)
: {
: T* i=new T[n];
: std::copy(from, from+n, i);
: int k;
: do {
: f(i);
: for (k = 0; k < n && ++i[k] > to[k]; i[k] = from[k], k++);
| t****t
发帖数: 6806 | 14 比如你要从11111循环到44444, 那from就是11111,to就是44444.
呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
把这句话翻译成C, 就是xentar的那一行for(...)了.
懂。
【在 z****e 的大作中提到】
: 句弱智疑问，
: from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
: 那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
: 我真要撞墙了，这么多解法，我就真是一个都没有理解。
: 原来还以为自己C++已经有感觉了呢。
| C**********n
发帖数: 100 | 15 问个弱问题，用了这个很牛的解法之后，复杂度有没有改进？
是不是还是和多重循环嵌套一样？
?
【在 t****t 的大作中提到】
: 比如你要从11111循环到44444, 那from就是11111,to就是44444.
: 呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
: 想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
: 换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
: 把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
: 把这句话翻译成C, 就是xentar的那一行for(...)了.
:
: 懂。
| t****t
发帖数: 6806 | 16
没有.
是.
【在 C**********n 的大作中提到】
: 问个弱问题，用了这个很牛的解法之后，复杂度有没有改进？
: 是不是还是和多重循环嵌套一样？
:
: ?
| z****e
发帖数: 2024 | 17 我理解了，并且把你和红猪侠的方法都代码验证了一下。
受益匪浅呀。高兴的要撞墙了。
另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
f(i);
我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
?
【在 t****t 的大作中提到】
: 比如你要从11111循环到44444, 那from就是11111,to就是44444.
: 呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
: 想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
: 换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
: 把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
: 把这句话翻译成C, 就是xentar的那一行for(...)了.
:
: 懂。
| l******e
发帖数: 12192 | 18 你duke哪个系的？
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
| t****t
发帖数: 6806 | 19 撞墙男, 那个callback只是给你看一下的, 不是重点. 加不加size都无所谓, 因为
caller知道尺寸, callback也很容易知道.
另外delete[]一般是把尺寸放在内存块的前面.
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
| t****t
发帖数: 6806 | 20 啥时候xentar变成红猪侠了, 红猪侠不是个写手吗?
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
| | | l******e
发帖数: 12192 | 21 为啥是男的？
【在 t****t 的大作中提到】
: 撞墙男, 那个callback只是给你看一下的, 不是重点. 加不加size都无所谓, 因为
: caller知道尺寸, callback也很容易知道.
: 另外delete[]一般是把尺寸放在内存块的前面.
| t****t
发帖数: 6806 | 22 缺省值?
【在 l******e 的大作中提到】
: 为啥是男的？
| z****e
发帖数: 2024 | 23 lol
【在 t****t 的大作中提到】
: 缺省值?
| h*****0
发帖数: 4889 | 24 写C语言的习惯就是多句话写成一句，读起来非常不爽。关键就是那个for循环，我写开
给你看：
for (k = 0; k < n; k++) {
i[k]++; // 自增1
if (i[k] > MAX[k]) {
i[k] = MIN[k]; // 要进位了，这位清0吧
} else {
break; //不用进位，所以结束了。
}
}
这下明白了吧？
【在 z****e 的大作中提到】
: 发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
: 墙呢，你在哪？
| h*****0
发帖数: 4889 | 25 这个跟c++无关，是c语言的基础。
懂。
【在 z****e 的大作中提到】
: 句弱智疑问，
: from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
: 那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
: 我真要撞墙了，这么多解法，我就真是一个都没有理解。
: 原来还以为自己C++已经有感觉了呢。
| w**********s
发帖数: 291 | 26 一个容易理解的方法：利用stl里面的permutation，找出所有四个数组Index的排列组
合，然后对每个排列组合进行你的操作。 | O*******d
发帖数: 20343 | 27 How about "要8个变量，都遍历一遍，每个从 0 to 2" ? | w**********s
发帖数: 291 | 28 遍历8个数组，就是找出8个数组index的排列组合吧？
这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
。这里最啰嗦的事情交给stl来漂亮地完成了。 | h*****0
发帖数: 4889 | 29 stl里的排列包括“可重复排列”？如11211
【在 w**********s 的大作中提到】
: 遍历8个数组，就是找出8个数组index的排列组合吧？
: 这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
: 。这里最啰嗦的事情交给stl来漂亮地完成了。
| t****t
发帖数: 6806 | 30 显然没有嘛, 题都没看清
【在 h*****0 的大作中提到】
: stl里的排列包括“可重复排列”？如11211
| | | v*s
发帖数: 946 | 31 看别人的喜欢这样的程序。
自己的喜欢写成一行，显摆。
【在 h*****0 的大作中提到】
: 写C语言的习惯就是多句话写成一句，读起来非常不爽。关键就是那个for循环，我写开
: 给你看：
: for (k = 0; k < n; k++) {
: i[k]++; // 自增1
: if (i[k] > MAX[k]) {
: i[k] = MIN[k]; // 要进位了，这位清0吧
: } else {
: break; //不用进位，所以结束了。
: }
: }
| O*******d
发帖数: 20343 | 32 在学校里写程序，别人越读不懂，就越有自豪感。
在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
【在 v*s 的大作中提到】
: 看别人的喜欢这样的程序。
: 自己的喜欢写成一行，显摆。
| h*****0
发帖数: 4889 | 33 本来就应该写得容易懂。
能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
【在 O*******d 的大作中提到】
: 在学校里写程序，别人越读不懂，就越有自豪感。
: 在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
| z****e
发帖数: 2024 | 34 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
【在 h*****0 的大作中提到】
: 本来就应该写得容易懂。
: 能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
| O*******d
发帖数: 20343 | 35 Big cow to be.
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
| a****l
发帖数: 8211 | 36 能保证自己写的东西别人很容易看懂就是一个小牛了.
【在 O*******d 的大作中提到】
: Big cow to be.
| O*******d
发帖数: 20343 | 37 Big cow to be, 后备大牛。
【在 a****l 的大作中提到】
: 能保证自己写的东西别人很容易看懂就是一个小牛了.
| h*****0
发帖数: 4889 | 38 半个牛人。
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
| s*******d
发帖数: 1027 | 39 k < 8 && ++i[k] > 4 是怎么run的？没看明白。。
【在 X****r 的大作中提到】
: 一个更通用的方法：
: int i[8] = {1, 1, 1, 1, 1, 1, 1, 1}
: int k;
: do {
: // do your stuff with i[0] to i[7]
: for (k = 0; k < 8 && ++i[k] > 4; i[k++] = 1);
: } while (k < 8);
:
: technique,
: mathematically
| z****e
发帖数: 2024 | 40 进位。
【在 s*******d 的大作中提到】
: k < 8 && ++i[k] > 4 是怎么run的？没看明白。。
| | | b*********n
发帖数: 1258 | 41 这里不是很明白
可以解释一下为什么i[k++]=from[k]是undefined吗？
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
| h*****0
发帖数: 4889 | 42 可以等效成：
i[k] = from [k];
k++;
也可能效果是：
i[k] = from[k + 1];
k++;
【在 b*********n 的大作中提到】
: 这里不是很明白
: 可以解释一下为什么i[k++]=from[k]是undefined吗？
| z****e
发帖数: 2024 | 43 要8个变量，都遍历一遍，每个从 1 to 4, need 4^8= 65536.
i need to define i1,i2,i3,...i8, then start 8 nested "for" loops.
is there any way i can do this more easily?
btw, the question is all about c++ syntax, and C++ programming technique,
language features.
Nothing about why i need to do this and how to improve this mathematically
is irrelevant.
Thanks 大牛们。
早谢了。 | X****r
发帖数: 3557 | 44 for (int i = 0; i < 65536; i++) {
int i1 = (i & 3) + 1；
int i2 = ((i >> 2) & 3) + 1;
int i3 = ((i >> 4) & 3) + 1;
int i4 = ((i >> 6) & 3) + 1;
int i5 = ((i >> 8) & 3) + 1;
int i6 = ((i >> 10) & 3) + 1;
int i7 = ((i >> 12) & 3) + 1;
int i8 = ((i >> 14) & 3) + 1;
// ...
}
technique,
mathematically
【在 z****e 的大作中提到】
: 要8个变量，都遍历一遍，每个从 1 to 4, need 4^8= 65536.
: i need to define i1,i2,i3,...i8, then start 8 nested "for" loops.
: is there any way i can do this more easily?
: btw, the question is all about c++ syntax, and C++ programming technique,
: language features.
: Nothing about why i need to do this and how to improve this mathematically
: is irrelevant.
: Thanks 大牛们。
: 早谢了。
| X****r
发帖数: 3557 | 45 一个更通用的方法：
int i[8] = {1, 1, 1, 1, 1, 1, 1, 1}
int k;
do {
// do your stuff with i[0] to i[7]
for (k = 0; k < 8 && ++i[k] > 4; i[k++] = 1);
} while (k < 8);
technique,
mathematically
【在 z****e 的大作中提到】
: 要8个变量，都遍历一遍，每个从 1 to 4, need 4^8= 65536.
: i need to define i1,i2,i3,...i8, then start 8 nested "for" loops.
: is there any way i can do this more easily?
: btw, the question is all about c++ syntax, and C++ programming technique,
: language features.
: Nothing about why i need to do this and how to improve this mathematically
: is irrelevant.
: Thanks 大牛们。
: 早谢了。
| z****e
发帖数: 2024 | 46 这看得我惊呆了。
有没有什么模板的方法，可以好多重循环，任意重的，可能不？
你这个通用的，和上面那个，我要好好理解一下，目前还消化不了。
【在 X****r 的大作中提到】
: 一个更通用的方法：
: int i[8] = {1, 1, 1, 1, 1, 1, 1, 1}
: int k;
: do {
: // do your stuff with i[0] to i[7]
: for (k = 0; k < 8 && ++i[k] > 4; i[k++] = 1);
: } while (k < 8);
:
: technique,
: mathematically
| X****r
发帖数: 3557 | 47 任意重的当然可以用这个方法，要不然怎么说更通用呢：
void multi_loop(int *from, int *to, int n,
void (*callback)(const int *, int)) {
int *i = new int[n];
int k;
for (k = 0; k < n; k++) {
i[k] = from[k];
}
do {
(*callback)(i, n);
for (k = 0; k < n && ++i[k] > to[k]; k++) {
i[k] = from[k];
}
} while (k < n);
delete[] i;
}
【在 z****e 的大作中提到】
: 这看得我惊呆了。
: 有没有什么模板的方法，可以好多重循环，任意重的，可能不？
: 你这个通用的，和上面那个，我要好好理解一下，目前还消化不了。
| t****t
发帖数: 6806 | 48 make it template:
template
void multi_loop(const T* from, const T* to, int n, F f)
{
T* i=new T[n];
std::copy(from, from+n, i);
int k;
do {
f(i);
for (k = 0; k < n && ++i[k] > to[k]; i[k] = from[k], k++);
while (k
delete [] i;
}
【在 X****r 的大作中提到】
: 任意重的当然可以用这个方法，要不然怎么说更通用呢：
: void multi_loop(int *from, int *to, int n,
: void (*callback)(const int *, int)) {
: int *i = new int[n];
: int k;
: for (k = 0; k < n; k++) {
: i[k] = from[k];
: }
: do {
: (*callback)(i, n);
| t****t
发帖数: 6806 | 49 (shouldn't use i[k++]=from[k] as it's undefined...)
【在 X****r 的大作中提到】
: 任意重的当然可以用这个方法，要不然怎么说更通用呢：
: void multi_loop(int *from, int *to, int n,
: void (*callback)(const int *, int)) {
: int *i = new int[n];
: int k;
: for (k = 0; k < n; k++) {
: i[k] = from[k];
: }
: do {
: (*callback)(i, n);
| X****r
发帖数: 3557 | 50 你说得对，抄下来的时候没看。
这样的话i[k] = from[k]放到for循环内部，
留k++作为for循环的第三个表达式好看一些。
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
| | | b******u
发帖数: 469 | 51 orz.
【在 X****r 的大作中提到】
: 一个更通用的方法：
: int i[8] = {1, 1, 1, 1, 1, 1, 1, 1}
: int k;
: do {
: // do your stuff with i[0] to i[7]
: for (k = 0; k < 8 && ++i[k] > 4; i[k++] = 1);
: } while (k < 8);
:
: technique,
: mathematically
| a**u
发帖数: 813 | 52 using recursive functions to do it.
【在 z****e 的大作中提到】
: 要8个变量，都遍历一遍，每个从 1 to 4, need 4^8= 65536.
: i need to define i1,i2,i3,...i8, then start 8 nested "for" loops.
: is there any way i can do this more easily?
: btw, the question is all about c++ syntax, and C++ programming technique,
: language features.
: Nothing about why i need to do this and how to improve this mathematically
: is irrelevant.
: Thanks 大牛们。
: 早谢了。
| z****e
发帖数: 2024 | 53 发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
墙呢，你在哪？ | z****e
发帖数: 2024 | 54 发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
墙呢，你在哪？ | z****e
发帖数: 2024 | 55 句弱智疑问，
from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
我真要撞墙了，这么多解法，我就真是一个都没有理解。
原来还以为自己C++已经有感觉了呢。
【在 t****t 的大作中提到】
: make it template:
: template
: void multi_loop(const T* from, const T* to, int n, F f)
: {
: T* i=new T[n];
: std::copy(from, from+n, i);
: int k;
: do {
: f(i);
: for (k = 0; k < n && ++i[k] > to[k]; i[k] = from[k], k++);
| t****t
发帖数: 6806 | 56 比如你要从11111循环到44444, 那from就是11111,to就是44444.
呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
把这句话翻译成C, 就是xentar的那一行for(...)了.
懂。
【在 z****e 的大作中提到】
: 句弱智疑问，
: from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
: 那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
: 我真要撞墙了，这么多解法，我就真是一个都没有理解。
: 原来还以为自己C++已经有感觉了呢。
| C**********n
发帖数: 100 | 57 问个弱问题，用了这个很牛的解法之后，复杂度有没有改进？
是不是还是和多重循环嵌套一样？
?
【在 t****t 的大作中提到】
: 比如你要从11111循环到44444, 那from就是11111,to就是44444.
: 呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
: 想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
: 换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
: 把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
: 把这句话翻译成C, 就是xentar的那一行for(...)了.
:
: 懂。
| t****t
发帖数: 6806 | 58
没有.
是.
【在 C**********n 的大作中提到】
: 问个弱问题，用了这个很牛的解法之后，复杂度有没有改进？
: 是不是还是和多重循环嵌套一样？
:
: ?
| z****e
发帖数: 2024 | 59 我理解了，并且把你和红猪侠的方法都代码验证了一下。
受益匪浅呀。高兴的要撞墙了。
另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
f(i);
我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
?
【在 t****t 的大作中提到】
: 比如你要从11111循环到44444, 那from就是11111,to就是44444.
: 呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
: 想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
: 换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
: 把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
: 把这句话翻译成C, 就是xentar的那一行for(...)了.
:
: 懂。
| l******e
发帖数: 12192 | 60 你duke哪个系的？
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
| | | t****t
发帖数: 6806 | 61 撞墙男, 那个callback只是给你看一下的, 不是重点. 加不加size都无所谓, 因为
caller知道尺寸, callback也很容易知道.
另外delete[]一般是把尺寸放在内存块的前面.
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
| t****t
发帖数: 6806 | 62 啥时候xentar变成红猪侠了, 红猪侠不是个写手吗?
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
| l******e
发帖数: 12192 | 63 为啥是男的？
【在 t****t 的大作中提到】
: 撞墙男, 那个callback只是给你看一下的, 不是重点. 加不加size都无所谓, 因为
: caller知道尺寸, callback也很容易知道.
: 另外delete[]一般是把尺寸放在内存块的前面.
| t****t
发帖数: 6806 | 64 缺省值?
【在 l******e 的大作中提到】
: 为啥是男的？
| z****e
发帖数: 2024 | 65 lol
【在 t****t 的大作中提到】
: 缺省值?
| h*****0
发帖数: 4889 | 66 写C语言的习惯就是多句话写成一句，读起来非常不爽。关键就是那个for循环，我写开
给你看：
for (k = 0; k < n; k++) {
i[k]++; // 自增1
if (i[k] > MAX[k]) {
i[k] = MIN[k]; // 要进位了，这位清0吧
} else {
break; //不用进位，所以结束了。
}
}
这下明白了吧？
【在 z****e 的大作中提到】
: 发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
: 墙呢，你在哪？
| h*****0
发帖数: 4889 | 67 这个跟c++无关，是c语言的基础。
懂。
【在 z****e 的大作中提到】
: 句弱智疑问，
: from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
: 那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
: 我真要撞墙了，这么多解法，我就真是一个都没有理解。
: 原来还以为自己C++已经有感觉了呢。
| w**********s
发帖数: 291 | 68 一个容易理解的方法：利用stl里面的permutation，找出所有四个数组Index的排列组
合，然后对每个排列组合进行你的操作。 | O*******d
发帖数: 20343 | 69 How about "要8个变量，都遍历一遍，每个从 0 to 2" ? | w**********s
发帖数: 291 | 70 遍历8个数组，就是找出8个数组index的排列组合吧？
这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
。这里最啰嗦的事情交给stl来漂亮地完成了。 | | | h*****0
发帖数: 4889 | 71 stl里的排列包括“可重复排列”？如11211
【在 w**********s 的大作中提到】
: 遍历8个数组，就是找出8个数组index的排列组合吧？
: 这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
: 。这里最啰嗦的事情交给stl来漂亮地完成了。
| t****t
发帖数: 6806 | 72 显然没有嘛, 题都没看清
【在 h*****0 的大作中提到】
: stl里的排列包括“可重复排列”？如11211
| O*******d
发帖数: 20343 | 73 在学校里写程序，别人越读不懂，就越有自豪感。
在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
【在 v*s 的大作中提到】
: 看别人的喜欢这样的程序。
: 自己的喜欢写成一行，显摆。
| h*****0
发帖数: 4889 | 74 本来就应该写得容易懂。
能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
【在 O*******d 的大作中提到】
: 在学校里写程序，别人越读不懂，就越有自豪感。
: 在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
| z****e
发帖数: 2024 | 75 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
【在 h*****0 的大作中提到】
: 本来就应该写得容易懂。
: 能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
| O*******d
发帖数: 20343 | 76 Big cow to be.
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
| a****l
发帖数: 8211 | 77 能保证自己写的东西别人很容易看懂就是一个小牛了.
【在 O*******d 的大作中提到】
: Big cow to be.
| O*******d
发帖数: 20343 | 78 Big cow to be, 后备大牛。
【在 a****l 的大作中提到】
: 能保证自己写的东西别人很容易看懂就是一个小牛了.
| h*****0
发帖数: 4889 | 79 半个牛人。
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
| s*******d
发帖数: 1027 | 80 k < 8 && ++i[k] > 4 是怎么run的？没看明白。。
【在 X****r 的大作中提到】
: 一个更通用的方法：
: int i[8] = {1, 1, 1, 1, 1, 1, 1, 1}
: int k;
: do {
: // do your stuff with i[0] to i[7]
: for (k = 0; k < 8 && ++i[k] > 4; i[k++] = 1);
: } while (k < 8);
:
: technique,
: mathematically
| | | z****e
发帖数: 2024 | 81 进位。
【在 s*******d 的大作中提到】
: k < 8 && ++i[k] > 4 是怎么run的？没看明白。。
| b*********n
发帖数: 1258 | 82 这里不是很明白
可以解释一下为什么i[k++]=from[k]是undefined吗？
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
| h*****0
发帖数: 4889 | 83 可以等效成：
i[k] = from [k];
k++;
也可能效果是：
i[k] = from[k + 1];
k++;
【在 b*********n 的大作中提到】
: 这里不是很明白
: 可以解释一下为什么i[k++]=from[k]是undefined吗？
| r****o
发帖数: 1950 | 84 我现在很喜欢把超过3层循环的code都用这种方法改写，这样用2层循环就够了。
不过我想知道，改写之后除了循环次数少了之后还有什么其他好处吗？
我想来想去，好像就感觉代码量少了些，好像效率没有大的提高?
大牛们怎么看这个问题？
是不是循环次数少了会导致效率高点呢？Cache? 流水线？并行
欢迎拍砖。
【在 h*****0 的大作中提到】
: 写C语言的习惯就是多句话写成一句，读起来非常不爽。关键就是那个for循环，我写开
: 给你看：
: for (k = 0; k < n; k++) {
: i[k]++; // 自增1
: if (i[k] > MAX[k]) {
: i[k] = MIN[k]; // 要进位了，这位清0吧
: } else {
: break; //不用进位，所以结束了。
: }
: }
| d***a
发帖数: 13752 | 85 呵呵，想起我高中时写Basic程序，写过这样的code。
"好像效率没有大的提高"：一般来说，效率要比原来稍低一些（假设C编程），因为循
环变量用i[0], i[1], i[2]等，比用i0, i1, i2的overhead大一点。主要的好处是灵活
，因为数组的长度可以做成可变的，这样做N层循环时，N不必是一个常数。
【在 r****o 的大作中提到】
: 我现在很喜欢把超过3层循环的code都用这种方法改写，这样用2层循环就够了。
: 不过我想知道，改写之后除了循环次数少了之后还有什么其他好处吗？
: 我想来想去，好像就感觉代码量少了些，好像效率没有大的提高?
: 大牛们怎么看这个问题？
: 是不是循环次数少了会导致效率高点呢？Cache? 流水线？并行
: 欢迎拍砖。
| m*********t
发帖数: 527 | 86 我觉得这个才应该被贴出来。前面把一堆东西挤在一行又没有改变复杂度。。。 I don
't see the point
【在 h*****0 的大作中提到】
: 写C语言的习惯就是多句话写成一句，读起来非常不爽。关键就是那个for循环，我写开
: 给你看：
: for (k = 0; k < n; k++) {
: i[k]++; // 自增1
: if (i[k] > MAX[k]) {
: i[k] = MIN[k]; // 要进位了，这位清0吧
: } else {
: break; //不用进位，所以结束了。
: }
: }
| r****o
发帖数: 1950 | 87 不懂为啥用数组就会效率稍低？
另外，循环层数低了，是不是从cache的角度来讲会效率稍微高些？
【在 d***a 的大作中提到】
: 呵呵，想起我高中时写Basic程序，写过这样的code。
: "好像效率没有大的提高"：一般来说，效率要比原来稍低一些（假设C编程），因为循
: 环变量用i[0], i[1], i[2]等，比用i0, i1, i2的overhead大一点。主要的好处是灵活
: ，因为数组的长度可以做成可变的，这样做N层循环时，N不必是一个常数。
| d***a
发帖数: 13752 | 88 i, j, k这样的循环变量，一般就直接用寄存器了，循环变量的访问不牵涉到内存。用
数组式的循环变量，就要访问内存了。对这个数组的访问，还要用一个循环变量。
只有几层的循环层数，用不用数组，对cache没什么影响。源代码看上去大了不少，似
乎要多占cache，但实际上，机器代码只多一点（每层多两条或三条机器指令）。
【在 r****o 的大作中提到】
: 不懂为啥用数组就会效率稍低？
: 另外，循环层数低了，是不是从cache的角度来讲会效率稍微高些？
| s*****V
发帖数: 21731 | 89 这个就是 几进制吧， 如果是1-4 就是4进制。从 1111 遍历到 4444. | r****o
发帖数: 1950 | 90 像下面这样的多层循环是不是也有一个hidden loop在里面，比如说当i1=1,i2=i3=i4=9
, i4再增加的时候，它要先比较i3,i2,而不是直接跳到i1。对吧?
for (i1=0;i1<10;i1++)
for (i2=0;i2<10;i2++)
for (i3=0;i3<10;i3++)
for (i4=0;i4<10;i4++)
{
}
【在 d***a 的大作中提到】
: i, j, k这样的循环变量，一般就直接用寄存器了，循环变量的访问不牵涉到内存。用
: 数组式的循环变量，就要访问内存了。对这个数组的访问，还要用一个循环变量。
: 只有几层的循环层数，用不用数组，对cache没什么影响。源代码看上去大了不少，似
: 乎要多占cache，但实际上，机器代码只多一点（每层多两条或三条机器指令）。
| | | t****t
发帖数: 6806 | 91 try focus on something else instead of this crap.
=9
【在 r****o 的大作中提到】
: 像下面这样的多层循环是不是也有一个hidden loop在里面，比如说当i1=1,i2=i3=i4=9
: , i4再增加的时候，它要先比较i3,i2,而不是直接跳到i1。对吧?
: for (i1=0;i1<10;i1++)
: for (i2=0;i2<10;i2++)
: for (i3=0;i3<10;i3++)
: for (i4=0;i4<10;i4++)
: {
: }
| i********r
发帖数: 131 | 92 thinking in c++11 and a more general solution:
#include
#include
using namespace std;
void do_something(const vector& vars)
{
cout << "do_something with loop variables: ";
for (auto& i: vars)
cout << i << " ";
cout << endl;
}
void myLoop(vector& vars)
{
do_something(vars);
}
template
void myLoop(vector& vars, unsigned int n, Args... args)
{
auto index = vars.size();
vars.push_back(0);
for (auto i = 0; i < n; ++i) {
vars[index] = i;
myLoop(vars, args...);
}
vars.erase(vars.end() - 1);
}
template
void variadicLoops(unsigned int n, Args... args)
{
vector vars;
myLoop(vars, n, args...);
}
// build: g++ -std=c++0x a.cpp (require 4.6.3 or above)
int main()
{
cout << "using variadic templates" << endl;
variadicLoops(2, 3);
variadicLoops(2, 3, 4);
// variadicLoops(); // compile error, which is good
return 0;
} | i********r
发帖数: 131 | 93 If the number of loops are only known at run time, the variadic template won
't work. The only way I can think of is recursion:
#include
#include
using namespace std;
void do_something(const vector& vars)
{
cout << "do_something with loop variables: ";
for (auto& i: vars)
cout << i << " ";
cout << endl;
}
// method 2:
void myLoop(const vector& inputs, vector& vars)
{
if (inputs.size() == vars.size()) {
do_something(vars);
} else {
auto index = vars.size();
vars.push_back(0);
for (auto i = 0; i < inputs[index]; ++i) {
vars[index] = i;
myLoop(inputs, vars);
}
vars.erase(vars.end() - 1);
}
}
void variadicLoops(const vector& inputs)
{
if (inputs.size() != 0) {
vector vars;
myLoop(inputs, vars);
}
}
int main()
{
cout << "using recursive function" << endl;
vector inputs;
variadicLoops(inputs); // do nothing but compile ok
inputs.push_back(2);
inputs.push_back(3);
variadicLoops(inputs);
inputs.push_back(4);
variadicLoops(inputs);
return 0;
} |
|
