z*e
2 楼
要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 大牛们。
早谢了。
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 大牛们。
早谢了。
M*t
3 楼
谢谢
s*0
4 楼
经过本人研究发现搞 marketing的有以下几类人
1.经济数学背景搞marketing model，这个我望尘莫及
2.BS, MBA 的做研究，好像这种研究挺杂,也不做model
3.心理学的研究decision science,不做model
我没有经济数学背景，设想心理学的做研究是展开心理调查来研究，那第二种 BS, MBA
的是从哪个角度做marketing 研究的呢？谢谢
1.经济数学背景搞marketing model，这个我望尘莫及
2.BS, MBA 的做研究，好像这种研究挺杂,也不做model
3.心理学的研究decision science,不做model
我没有经济数学背景，设想心理学的做研究是展开心理调查来研究，那第二种 BS, MBA
的是从哪个角度做marketing 研究的呢？谢谢
d*y
5 楼
不知那位达人可以解答一下。
土木和环境版都门可罗雀，但为啥还分成两个版呢，不知道有何典故？在国内土木和环
境一般是分开的院系，但在这基本都是一起的。
还有，这个版的版主的方针基本上是劝大家转行，不知道是何故？
土木和环境版都门可罗雀，但为啥还分成两个版呢，不知道有何典故？在国内土木和环
境一般是分开的院系，但在这基本都是一起的。
还有，这个版的版主的方针基本上是劝大家转行，不知道是何故？
N*t
6 楼
小弟刚从一所60-70的学校MSEE毕业，DSP & Embedded 方向。OPT找工作2个多月了，联
系我的不是猎头就是要求有身份的，相当郁闷。前几天老板突然想让我留下PhD，由于
经费用光，第一年只能免学费，方向是cooperative communication，基本只会用到
MATLAB。因为要开学了，老板让2周内给答复。
想请教下各位前辈这个PhD值不值得读。本人对research兴趣一般，怕读了3，4年后，
工业界要的skill没什么长进，PhD反成了找工作的累赘。实在不行就破釜沉舟，挂个
volunteer继续找工作，也不知市场什么时候能好起来。不过又感觉有点对不起老板，
他人还是挺nice的。请各位给小弟出出主意，拜谢！
系我的不是猎头就是要求有身份的，相当郁闷。前几天老板突然想让我留下PhD，由于
经费用光，第一年只能免学费，方向是cooperative communication，基本只会用到
MATLAB。因为要开学了，老板让2周内给答复。
想请教下各位前辈这个PhD值不值得读。本人对research兴趣一般，怕读了3，4年后，
工业界要的skill没什么长进，PhD反成了找工作的累赘。实在不行就破釜沉舟，挂个
volunteer继续找工作，也不知市场什么时候能好起来。不过又感觉有点对不起老板，
他人还是挺nice的。请各位给小弟出出主意，拜谢！
i*l
7 楼
等咱做了皇帝 左边大饼 右边馍馍
【在 b***e 的大作中提到】
: 胡军很有男人味。
【在 b***e 的大作中提到】
: 胡军很有男人味。
X*r
8 楼
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 大牛们。
: 早谢了。
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 大牛们。
: 早谢了。
S*I
9 楼
inkscape
【在 M********t 的大作中提到】
: 谢谢
【在 M********t 的大作中提到】
: 谢谢
z*k
10 楼
第一，不存在你说的2
第二，3那块研究的东西很多，实验居多，也有定性方法
第三，另外还有个方向叫战略，牛校的学生和年轻教授没有人做，烂校和老人们做得多些
MBA
【在 s********0 的大作中提到】
: 经过本人研究发现搞 marketing的有以下几类人
: 1.经济数学背景搞marketing model，这个我望尘莫及
: 2.BS, MBA 的做研究，好像这种研究挺杂,也不做model
: 3.心理学的研究decision science,不做model
: 我没有经济数学背景，设想心理学的做研究是展开心理调查来研究，那第二种 BS, MBA
: 的是从哪个角度做marketing 研究的呢？谢谢
第二，3那块研究的东西很多，实验居多，也有定性方法
第三，另外还有个方向叫战略，牛校的学生和年轻教授没有人做，烂校和老人们做得多些
MBA
【在 s********0 的大作中提到】
: 经过本人研究发现搞 marketing的有以下几类人
: 1.经济数学背景搞marketing model，这个我望尘莫及
: 2.BS, MBA 的做研究，好像这种研究挺杂,也不做model
: 3.心理学的研究decision science,不做model
: 我没有经济数学背景，设想心理学的做研究是展开心理调查来研究，那第二种 BS, MBA
: 的是从哪个角度做marketing 研究的呢？谢谢
C*S
11 楼
1. very different majors...
2. social recognition measured by money?
【在 d****y 的大作中提到】
: 不知那位达人可以解答一下。
: 土木和环境版都门可罗雀，但为啥还分成两个版呢，不知道有何典故？在国内土木和环
: 境一般是分开的院系，但在这基本都是一起的。
: 还有，这个版的版主的方针基本上是劝大家转行，不知道是何故？
2. social recognition measured by money?
【在 d****y 的大作中提到】
: 不知那位达人可以解答一下。
: 土木和环境版都门可罗雀，但为啥还分成两个版呢，不知道有何典故？在国内土木和环
: 境一般是分开的院系，但在这基本都是一起的。
: 还有，这个版的版主的方针基本上是劝大家转行，不知道是何故？
r*n
12 楼
物理层的cc？有点转方向啊.......
至于这个方向的前景嘛........看看本版之前讨论PHD的那几个帖子，归纳起来就是物
理层的无限通信不太容易找工作，就现在的就业环境来看
至于这个方向的前景嘛........看看本版之前讨论PHD的那几个帖子，归纳起来就是物
理层的无限通信不太容易找工作，就现在的就业环境来看
X*r
13 楼
一个更通用的方法：
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 大牛们。
: 早谢了。
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 大牛们。
: 早谢了。
w*g
14 楼
powerpoint.
【在 M********t 的大作中提到】
: 谢谢
【在 M********t 的大作中提到】
: 谢谢
p*t
15 楼
既然是BS,MBA，为啥又扯到PHD去了？
MBA
【在 s********0 的大作中提到】
: 经过本人研究发现搞 marketing的有以下几类人
: 1.经济数学背景搞marketing model，这个我望尘莫及
: 2.BS, MBA 的做研究，好像这种研究挺杂,也不做model
: 3.心理学的研究decision science,不做model
: 我没有经济数学背景，设想心理学的做研究是展开心理调查来研究，那第二种 BS, MBA
: 的是从哪个角度做marketing 研究的呢？谢谢
MBA
【在 s********0 的大作中提到】
: 经过本人研究发现搞 marketing的有以下几类人
: 1.经济数学背景搞marketing model，这个我望尘莫及
: 2.BS, MBA 的做研究，好像这种研究挺杂,也不做model
: 3.心理学的研究decision science,不做model
: 我没有经济数学背景，设想心理学的做研究是展开心理调查来研究，那第二种 BS, MBA
: 的是从哪个角度做marketing 研究的呢？谢谢
b*r
16 楼
查查CS PhD的起薪和Civil PhD的起薪就知道。
Civil PhD是又要编程又要做实验，CS只要编程就行了。
【在 d****y 的大作中提到】
: 不知那位达人可以解答一下。
: 土木和环境版都门可罗雀，但为啥还分成两个版呢，不知道有何典故？在国内土木和环
: 境一般是分开的院系，但在这基本都是一起的。
: 还有，这个版的版主的方针基本上是劝大家转行，不知道是何故？
Civil PhD是又要编程又要做实验，CS只要编程就行了。
【在 d****y 的大作中提到】
: 不知那位达人可以解答一下。
: 土木和环境版都门可罗雀，但为啥还分成两个版呢，不知道有何典故？在国内土木和环
: 境一般是分开的院系，但在这基本都是一起的。
: 还有，这个版的版主的方针基本上是劝大家转行，不知道是何故？
N*t
17 楼
方向还好，我master做的就是DSP实现他的那几个算法。确实物理层不好找工作，以前
几个此方向毕业的师兄也都没找到工业界的职位。
【在 r*********n 的大作中提到】
: 物理层的cc？有点转方向啊.......
: 至于这个方向的前景嘛........看看本版之前讨论PHD的那几个帖子，归纳起来就是物
: 理层的无限通信不太容易找工作，就现在的就业环境来看
几个此方向毕业的师兄也都没找到工业界的职位。
【在 r*********n 的大作中提到】
: 物理层的cc？有点转方向啊.......
: 至于这个方向的前景嘛........看看本版之前讨论PHD的那几个帖子，归纳起来就是物
: 理层的无限通信不太容易找工作，就现在的就业环境来看
z*e
18 楼
这看得我惊呆了。
有没有什么模板的方法，可以好多重循环，任意重的，可能不？
你这个通用的，和上面那个，我要好好理解一下，目前还消化不了。
【在 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 的大作中提到】
: 一个更通用的方法：
: 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
M*t
19 楼
谢谢大家，我去试试
s*0
20 楼
谢谢指点，很多烂校有MBA录到marketing的，牛校也有一两个。查到了，很对，他们一
般做strategy,management,consumer behavior. 奇怪这些不做model怎么做研究
多些
【在 z****k 的大作中提到】
: 第一，不存在你说的2
: 第二，3那块研究的东西很多，实验居多，也有定性方法
: 第三，另外还有个方向叫战略，牛校的学生和年轻教授没有人做，烂校和老人们做得多些
:
: MBA
般做strategy,management,consumer behavior. 奇怪这些不做model怎么做研究
多些
【在 z****k 的大作中提到】
: 第一，不存在你说的2
: 第二，3那块研究的东西很多，实验居多，也有定性方法
: 第三，另外还有个方向叫战略，牛校的学生和年轻教授没有人做，烂校和老人们做得多些
:
: MBA
d*y
21 楼
这和我的问题有关联吗？
【在 b****r 的大作中提到】
: 查查CS PhD的起薪和Civil PhD的起薪就知道。
: Civil PhD是又要编程又要做实验，CS只要编程就行了。
【在 b****r 的大作中提到】
: 查查CS PhD的起薪和Civil PhD的起薪就知道。
: Civil PhD是又要编程又要做实验，CS只要编程就行了。
m*t
22 楼
DSP or PHY layer is not very easy to find a job,
PhD may be a better/safer choice in this recessional time
【在 N*****t 的大作中提到】
: 小弟刚从一所60-70的学校MSEE毕业，DSP & Embedded 方向。OPT找工作2个多月了，联
: 系我的不是猎头就是要求有身份的，相当郁闷。前几天老板突然想让我留下PhD，由于
: 经费用光，第一年只能免学费，方向是cooperative communication，基本只会用到
: MATLAB。因为要开学了，老板让2周内给答复。
: 想请教下各位前辈这个PhD值不值得读。本人对research兴趣一般，怕读了3，4年后，
: 工业界要的skill没什么长进，PhD反成了找工作的累赘。实在不行就破釜沉舟，挂个
: volunteer继续找工作，也不知市场什么时候能好起来。不过又感觉有点对不起老板，
: 他人还是挺nice的。请各位给小弟出出主意，拜谢！
PhD may be a better/safer choice in this recessional time
【在 N*****t 的大作中提到】
: 小弟刚从一所60-70的学校MSEE毕业，DSP & Embedded 方向。OPT找工作2个多月了，联
: 系我的不是猎头就是要求有身份的，相当郁闷。前几天老板突然想让我留下PhD，由于
: 经费用光，第一年只能免学费，方向是cooperative communication，基本只会用到
: MATLAB。因为要开学了，老板让2周内给答复。
: 想请教下各位前辈这个PhD值不值得读。本人对research兴趣一般，怕读了3，4年后，
: 工业界要的skill没什么长进，PhD反成了找工作的累赘。实在不行就破釜沉舟，挂个
: volunteer继续找工作，也不知市场什么时候能好起来。不过又感觉有点对不起老板，
: 他人还是挺nice的。请各位给小弟出出主意，拜谢！
X*r
23 楼
任意重的当然可以用这个方法，要不然怎么说更通用呢：
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 的大作中提到】
: 这看得我惊呆了。
: 有没有什么模板的方法，可以好多重循环，任意重的，可能不？
: 你这个通用的，和上面那个，我要好好理解一下，目前还消化不了。
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 的大作中提到】
: 这看得我惊呆了。
: 有没有什么模板的方法，可以好多重循环，任意重的，可能不？
: 你这个通用的，和上面那个，我要好好理解一下，目前还消化不了。
b*z
24 楼
A9CAD
p*t
25 楼
MBA当marketing 的faculty?
【在 s********0 的大作中提到】
: 谢谢指点，很多烂校有MBA录到marketing的，牛校也有一两个。查到了，很对，他们一
: 般做strategy,management,consumer behavior. 奇怪这些不做model怎么做研究
:
: 多些
【在 s********0 的大作中提到】
: 谢谢指点，很多烂校有MBA录到marketing的，牛校也有一两个。查到了，很对，他们一
: 般做strategy,management,consumer behavior. 奇怪这些不做model怎么做研究
:
: 多些
z*i
26 楼
他大概穿越了~~~
【在 d****y 的大作中提到】
: 这和我的问题有关联吗？
【在 d****y 的大作中提到】
: 这和我的问题有关联吗？
w*o
27 楼
it is not bad to have a offer on hand
t*t
28 楼
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
}
【在 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);
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
}
【在 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);
S*a
29 楼
Canvas
★ 发自iPhone App: ChineseWeb 8.6
【在 M********t 的大作中提到】
: 谢谢
★ 发自iPhone App: ChineseWeb 8.6
【在 M********t 的大作中提到】
: 谢谢
j*l
30 楼
请推荐几篇1类 的经典文章给我。我是商学院别的专业的，数学还行。
MBA
【在 s********0 的大作中提到】
: 经过本人研究发现搞 marketing的有以下几类人
: 1.经济数学背景搞marketing model，这个我望尘莫及
: 2.BS, MBA 的做研究，好像这种研究挺杂,也不做model
: 3.心理学的研究decision science,不做model
: 我没有经济数学背景，设想心理学的做研究是展开心理调查来研究，那第二种 BS, MBA
: 的是从哪个角度做marketing 研究的呢？谢谢
MBA
【在 s********0 的大作中提到】
: 经过本人研究发现搞 marketing的有以下几类人
: 1.经济数学背景搞marketing model，这个我望尘莫及
: 2.BS, MBA 的做研究，好像这种研究挺杂,也不做model
: 3.心理学的研究decision science,不做model
: 我没有经济数学背景，设想心理学的做研究是展开心理调查来研究，那第二种 BS, MBA
: 的是从哪个角度做marketing 研究的呢？谢谢
H*l
31 楼
agree
DSP calls more on experience rather than any degree
esp. in this at-least-seems-shitty market (fxck my poor english..5555555555)
【在 m***t 的大作中提到】
: DSP or PHY layer is not very easy to find a job,
: PhD may be a better/safer choice in this recessional time
DSP calls more on experience rather than any degree
esp. in this at-least-seems-shitty market (fxck my poor english..5555555555)
【在 m***t 的大作中提到】
: DSP or PHY layer is not very easy to find a job,
: PhD may be a better/safer choice in this recessional time
t*t
32 楼
(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 的大作中提到】
: 任意重的当然可以用这个方法，要不然怎么说更通用呢：
: 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);
b*2
33 楼
日。
跟我情况一样啊。不过我正好反过来，本来打算继续phd的，但是老板经费用光，所以
也两手准备，被迫出来找找工作了。
【在 N*****t 的大作中提到】
: 小弟刚从一所60-70的学校MSEE毕业，DSP & Embedded 方向。OPT找工作2个多月了，联
: 系我的不是猎头就是要求有身份的，相当郁闷。前几天老板突然想让我留下PhD，由于
: 经费用光，第一年只能免学费，方向是cooperative communication，基本只会用到
: MATLAB。因为要开学了，老板让2周内给答复。
: 想请教下各位前辈这个PhD值不值得读。本人对research兴趣一般，怕读了3，4年后，
: 工业界要的skill没什么长进，PhD反成了找工作的累赘。实在不行就破釜沉舟，挂个
: volunteer继续找工作，也不知市场什么时候能好起来。不过又感觉有点对不起老板，
: 他人还是挺nice的。请各位给小弟出出主意，拜谢！
跟我情况一样啊。不过我正好反过来，本来打算继续phd的，但是老板经费用光，所以
也两手准备，被迫出来找找工作了。
【在 N*****t 的大作中提到】
: 小弟刚从一所60-70的学校MSEE毕业，DSP & Embedded 方向。OPT找工作2个多月了，联
: 系我的不是猎头就是要求有身份的，相当郁闷。前几天老板突然想让我留下PhD，由于
: 经费用光，第一年只能免学费，方向是cooperative communication，基本只会用到
: MATLAB。因为要开学了，老板让2周内给答复。
: 想请教下各位前辈这个PhD值不值得读。本人对research兴趣一般，怕读了3，4年后，
: 工业界要的skill没什么长进，PhD反成了找工作的累赘。实在不行就破釜沉舟，挂个
: volunteer继续找工作，也不知市场什么时候能好起来。不过又感觉有点对不起老板，
: 他人还是挺nice的。请各位给小弟出出主意，拜谢！
X*r
34 楼
你说得对，抄下来的时候没看。
这样的话i[k] = from[k]放到for循环内部，
留k++作为for循环的第三个表达式好看一些。
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
这样的话i[k] = from[k]放到for循环内部，
留k++作为for循环的第三个表达式好看一些。
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
g*t
35 楼
想读phd,找个奖学金应该不难吧。
【在 b*******2 的大作中提到】
: 日。
: 跟我情况一样啊。不过我正好反过来，本来打算继续phd的，但是老板经费用光，所以
: 也两手准备，被迫出来找找工作了。
【在 b*******2 的大作中提到】
: 日。
: 跟我情况一样啊。不过我正好反过来，本来打算继续phd的，但是老板经费用光，所以
: 也两手准备，被迫出来找找工作了。
b*u
36 楼
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
【在 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
b*2
37 楼
不想转学,比较难.实在不想重新申请,麻烦.
老板没钱给RA,系里不给TA.
【在 g****t 的大作中提到】
: 想读phd,找个奖学金应该不难吧。
老板没钱给RA,系里不给TA.
【在 g****t 的大作中提到】
: 想读phd,找个奖学金应该不难吧。
a*u
38 楼
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 的大作中提到】
: 要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
39 楼
发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
墙呢，你在哪？
墙呢，你在哪？
z*e
40 楼
发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
墙呢，你在哪？
墙呢，你在哪？
z*e
41 楼
句弱智疑问，
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++);
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
42 楼
比如你要从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++已经有感觉了呢。
呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
把这句话翻译成C, 就是xentar的那一行for(...)了.
懂。
【在 z****e 的大作中提到】
: 句弱智疑问，
: from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
: 那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
: 我真要撞墙了，这么多解法，我就真是一个都没有理解。
: 原来还以为自己C++已经有感觉了呢。
C*n
43 楼
问个弱问题，用了这个很牛的解法之后，复杂度有没有改进？
是不是还是和多重循环嵌套一样？
?
【在 t****t 的大作中提到】
: 比如你要从11111循环到44444, 那from就是11111,to就是44444.
: 呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
: 想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
: 换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
: 把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
: 把这句话翻译成C, 就是xentar的那一行for(...)了.
:
: 懂。
是不是还是和多重循环嵌套一样？
?
【在 t****t 的大作中提到】
: 比如你要从11111循环到44444, 那from就是11111,to就是44444.
: 呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
: 想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
: 换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
: 把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
: 把这句话翻译成C, 就是xentar的那一行for(...)了.
:
: 懂。
t*t
44 楼
没有.
是.
【在 C**********n 的大作中提到】
: 问个弱问题，用了这个很牛的解法之后，复杂度有没有改进？
: 是不是还是和多重循环嵌套一样？
:
: ?
z*e
45 楼
我理解了，并且把你和红猪侠的方法都代码验证了一下。
受益匪浅呀。高兴的要撞墙了。
另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
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(...)了.
:
: 懂。
受益匪浅呀。高兴的要撞墙了。
另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
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
46 楼
你duke哪个系的？
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
t*t
47 楼
撞墙男, 那个callback只是给你看一下的, 不是重点. 加不加size都无所谓, 因为
caller知道尺寸, callback也很容易知道.
另外delete[]一般是把尺寸放在内存块的前面.
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
caller知道尺寸, callback也很容易知道.
另外delete[]一般是把尺寸放在内存块的前面.
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
t*t
48 楼
啥时候xentar变成红猪侠了, 红猪侠不是个写手吗?
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
l*e
49 楼
为啥是男的？
【在 t****t 的大作中提到】
: 撞墙男, 那个callback只是给你看一下的, 不是重点. 加不加size都无所谓, 因为
: caller知道尺寸, callback也很容易知道.
: 另外delete[]一般是把尺寸放在内存块的前面.
【在 t****t 的大作中提到】
: 撞墙男, 那个callback只是给你看一下的, 不是重点. 加不加size都无所谓, 因为
: caller知道尺寸, callback也很容易知道.
: 另外delete[]一般是把尺寸放在内存块的前面.
t*t
50 楼
缺省值?
【在 l******e 的大作中提到】
: 为啥是男的？
【在 l******e 的大作中提到】
: 为啥是男的？
z*e
51 楼
lol
【在 t****t 的大作中提到】
: 缺省值?
【在 t****t 的大作中提到】
: 缺省值?
h*0
52 楼
写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 的大作中提到】
: 发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
: 墙呢，你在哪？
给你看：
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
53 楼
这个跟c++无关，是c语言的基础。
懂。
【在 z****e 的大作中提到】
: 句弱智疑问，
: from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
: 那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
: 我真要撞墙了，这么多解法，我就真是一个都没有理解。
: 原来还以为自己C++已经有感觉了呢。
懂。
【在 z****e 的大作中提到】
: 句弱智疑问，
: from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
: 那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
: 我真要撞墙了，这么多解法，我就真是一个都没有理解。
: 原来还以为自己C++已经有感觉了呢。
w*s
54 楼
一个容易理解的方法：利用stl里面的permutation，找出所有四个数组Index的排列组
合，然后对每个排列组合进行你的操作。
合，然后对每个排列组合进行你的操作。
O*d
55 楼
How about "要8个变量，都遍历一遍，每个从 0 to 2" ?
w*s
56 楼
遍历8个数组，就是找出8个数组index的排列组合吧？
这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
。这里最啰嗦的事情交给stl来漂亮地完成了。
这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
。这里最啰嗦的事情交给stl来漂亮地完成了。
h*0
57 楼
stl里的排列包括“可重复排列”？如11211
【在 w**********s 的大作中提到】
: 遍历8个数组，就是找出8个数组index的排列组合吧？
: 这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
: 。这里最啰嗦的事情交给stl来漂亮地完成了。
【在 w**********s 的大作中提到】
: 遍历8个数组，就是找出8个数组index的排列组合吧？
: 这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
: 。这里最啰嗦的事情交给stl来漂亮地完成了。
t*t
58 楼
显然没有嘛, 题都没看清
【在 h*****0 的大作中提到】
: stl里的排列包括“可重复排列”？如11211
【在 h*****0 的大作中提到】
: stl里的排列包括“可重复排列”？如11211
v*s
59 楼
看别人的喜欢这样的程序。
自己的喜欢写成一行，显摆。
【在 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; //不用进位，所以结束了。
: }
: }
自己的喜欢写成一行，显摆。
【在 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
60 楼
在学校里写程序，别人越读不懂，就越有自豪感。
在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
【在 v*s 的大作中提到】
: 看别人的喜欢这样的程序。
: 自己的喜欢写成一行，显摆。
在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
【在 v*s 的大作中提到】
: 看别人的喜欢这样的程序。
: 自己的喜欢写成一行，显摆。
h*0
61 楼
本来就应该写得容易懂。
能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
【在 O*******d 的大作中提到】
: 在学校里写程序，别人越读不懂，就越有自豪感。
: 在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
【在 O*******d 的大作中提到】
: 在学校里写程序，别人越读不懂，就越有自豪感。
: 在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
z*e
62 楼
我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
【在 h*****0 的大作中提到】
: 本来就应该写得容易懂。
: 能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
【在 h*****0 的大作中提到】
: 本来就应该写得容易懂。
: 能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
O*d
63 楼
Big cow to be.
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
a*l
64 楼
能保证自己写的东西别人很容易看懂就是一个小牛了.
【在 O*******d 的大作中提到】
: Big cow to be.
【在 O*******d 的大作中提到】
: Big cow to be.
O*d
65 楼
Big cow to be, 后备大牛。
【在 a****l 的大作中提到】
: 能保证自己写的东西别人很容易看懂就是一个小牛了.
【在 a****l 的大作中提到】
: 能保证自己写的东西别人很容易看懂就是一个小牛了.
h*0
66 楼
半个牛人。
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
s*d
67 楼
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
【在 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
68 楼
进位。
【在 s*******d 的大作中提到】
: k < 8 && ++i[k] > 4 是怎么run的？没看明白。。
【在 s*******d 的大作中提到】
: k < 8 && ++i[k] > 4 是怎么run的？没看明白。。
b*n
69 楼
这里不是很明白
可以解释一下为什么i[k++]=from[k]是undefined吗？
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
可以解释一下为什么i[k++]=from[k]是undefined吗？
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
h*0
70 楼
可以等效成：
i[k] = from [k];
k++;
也可能效果是：
i[k] = from[k + 1];
k++;
【在 b*********n 的大作中提到】
: 这里不是很明白
: 可以解释一下为什么i[k++]=from[k]是undefined吗？
i[k] = from [k];
k++;
也可能效果是：
i[k] = from[k + 1];
k++;
【在 b*********n 的大作中提到】
: 这里不是很明白
: 可以解释一下为什么i[k++]=from[k]是undefined吗？
z*e
71 楼
要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 大牛们。
早谢了。
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
72 楼
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 大牛们。
: 早谢了。
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
73 楼
一个更通用的方法：
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 大牛们。
: 早谢了。
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
74 楼
这看得我惊呆了。
有没有什么模板的方法，可以好多重循环，任意重的，可能不？
你这个通用的，和上面那个，我要好好理解一下，目前还消化不了。
【在 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 的大作中提到】
: 一个更通用的方法：
: 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
75 楼
任意重的当然可以用这个方法，要不然怎么说更通用呢：
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 的大作中提到】
: 这看得我惊呆了。
: 有没有什么模板的方法，可以好多重循环，任意重的，可能不？
: 你这个通用的，和上面那个，我要好好理解一下，目前还消化不了。
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
76 楼
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
}
【在 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);
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
}
【在 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
77 楼
(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 的大作中提到】
: 任意重的当然可以用这个方法，要不然怎么说更通用呢：
: 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
78 楼
你说得对，抄下来的时候没看。
这样的话i[k] = from[k]放到for循环内部，
留k++作为for循环的第三个表达式好看一些。
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
这样的话i[k] = from[k]放到for循环内部，
留k++作为for循环的第三个表达式好看一些。
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
b*u
79 楼
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
【在 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
80 楼
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 的大作中提到】
: 要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
81 楼
发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
墙呢，你在哪？
墙呢，你在哪？
z*e
82 楼
发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
墙呢，你在哪？
墙呢，你在哪？
z*e
83 楼
句弱智疑问，
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++);
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
84 楼
比如你要从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++已经有感觉了呢。
呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
把这句话翻译成C, 就是xentar的那一行for(...)了.
懂。
【在 z****e 的大作中提到】
: 句弱智疑问，
: from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
: 那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
: 我真要撞墙了，这么多解法，我就真是一个都没有理解。
: 原来还以为自己C++已经有感觉了呢。
C*n
85 楼
问个弱问题，用了这个很牛的解法之后，复杂度有没有改进？
是不是还是和多重循环嵌套一样？
?
【在 t****t 的大作中提到】
: 比如你要从11111循环到44444, 那from就是11111,to就是44444.
: 呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
: 想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
: 换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
: 把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
: 把这句话翻译成C, 就是xentar的那一行for(...)了.
:
: 懂。
是不是还是和多重循环嵌套一样？
?
【在 t****t 的大作中提到】
: 比如你要从11111循环到44444, 那from就是11111,to就是44444.
: 呃, 其实没有"这么多解法", 通用的解法就贴了一个, 其余的都是语法变化.
: 想要理解其实很容易, 你想想如果是你手工从一个排列产生下一个排列, 是怎么做的?
: 换个更特殊的例子, 如果你要从000循环到999, 你怎么做? 数数会的吧?
: 把最后一位加1, 如果>9就回到0, 再把前一位加1, 如果>9就回到0, 如此循环.
: 把这句话翻译成C, 就是xentar的那一行for(...)了.
:
: 懂。
t*t
86 楼
没有.
是.
【在 C**********n 的大作中提到】
: 问个弱问题，用了这个很牛的解法之后，复杂度有没有改进？
: 是不是还是和多重循环嵌套一样？
:
: ?
z*e
87 楼
我理解了，并且把你和红猪侠的方法都代码验证了一下。
受益匪浅呀。高兴的要撞墙了。
另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
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(...)了.
:
: 懂。
受益匪浅呀。高兴的要撞墙了。
另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
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
88 楼
你duke哪个系的？
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
t*t
89 楼
撞墙男, 那个callback只是给你看一下的, 不是重点. 加不加size都无所谓, 因为
caller知道尺寸, callback也很容易知道.
另外delete[]一般是把尺寸放在内存块的前面.
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
caller知道尺寸, callback也很容易知道.
另外delete[]一般是把尺寸放在内存块的前面.
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
t*t
90 楼
啥时候xentar变成红猪侠了, 红猪侠不是个写手吗?
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
【在 z****e 的大作中提到】
: 我理解了，并且把你和红猪侠的方法都代码验证了一下。
: 受益匪浅呀。高兴的要撞墙了。
: 另外，金无足赤，你那个模板的方法有一个小小的瑕疵，很小很小，就是
: f(i);
: 我觉得还是f(int* , size_t n)好些。毕竟函数不知道new的那个数组多大，我知道电
: 脑知道，因为delete的时候需要知道，但是我不知道电脑怎么知道的。
: 我不知道你知不知道电脑怎么知道被销毁的那个new的数组原来多大的？
:
: ?
l*e
91 楼
为啥是男的？
【在 t****t 的大作中提到】
: 撞墙男, 那个callback只是给你看一下的, 不是重点. 加不加size都无所谓, 因为
: caller知道尺寸, callback也很容易知道.
: 另外delete[]一般是把尺寸放在内存块的前面.
【在 t****t 的大作中提到】
: 撞墙男, 那个callback只是给你看一下的, 不是重点. 加不加size都无所谓, 因为
: caller知道尺寸, callback也很容易知道.
: 另外delete[]一般是把尺寸放在内存块的前面.
t*t
92 楼
缺省值?
【在 l******e 的大作中提到】
: 为啥是男的？
【在 l******e 的大作中提到】
: 为啥是男的？
z*e
93 楼
lol
【在 t****t 的大作中提到】
: 缺省值?
【在 t****t 的大作中提到】
: 缺省值?
h*0
94 楼
写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 的大作中提到】
: 发现自己太愚蠢了，目前为止，一个方法也没有完全理解。
: 墙呢，你在哪？
给你看：
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
95 楼
这个跟c++无关，是c语言的基础。
懂。
【在 z****e 的大作中提到】
: 句弱智疑问，
: from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
: 那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
: 我真要撞墙了，这么多解法，我就真是一个都没有理解。
: 原来还以为自己C++已经有感觉了呢。
懂。
【在 z****e 的大作中提到】
: 句弱智疑问，
: from, to ,都是代表啥？没想明白。尤其++i[k] > to[k]，简直是神来之笔，不是很懂。
: 那个f，就是我要干的事情是吧？一个需要所有变量排列的函数对吧？
: 我真要撞墙了，这么多解法，我就真是一个都没有理解。
: 原来还以为自己C++已经有感觉了呢。
w*s
96 楼
一个容易理解的方法：利用stl里面的permutation，找出所有四个数组Index的排列组
合，然后对每个排列组合进行你的操作。
合，然后对每个排列组合进行你的操作。
O*d
97 楼
How about "要8个变量，都遍历一遍，每个从 0 to 2" ?
w*s
98 楼
遍历8个数组，就是找出8个数组index的排列组合吧？
这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
。这里最啰嗦的事情交给stl来漂亮地完成了。
这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
。这里最啰嗦的事情交给stl来漂亮地完成了。
h*0
99 楼
stl里的排列包括“可重复排列”？如11211
【在 w**********s 的大作中提到】
: 遍历8个数组，就是找出8个数组index的排列组合吧？
: 这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
: 。这里最啰嗦的事情交给stl来漂亮地完成了。
【在 w**********s 的大作中提到】
: 遍历8个数组，就是找出8个数组index的排列组合吧？
: 这个stl可以完成。寻找完全的排列组合，应该说对n重循环提供了一个比较简洁的方法
: 。这里最啰嗦的事情交给stl来漂亮地完成了。
t*t
100 楼
显然没有嘛, 题都没看清
【在 h*****0 的大作中提到】
: stl里的排列包括“可重复排列”？如11211
【在 h*****0 的大作中提到】
: stl里的排列包括“可重复排列”？如11211
O*d
101 楼
在学校里写程序，别人越读不懂，就越有自豪感。
在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
【在 v*s 的大作中提到】
: 看别人的喜欢这样的程序。
: 自己的喜欢写成一行，显摆。
在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
【在 v*s 的大作中提到】
: 看别人的喜欢这样的程序。
: 自己的喜欢写成一行，显摆。
h*0
102 楼
本来就应该写得容易懂。
能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
【在 O*******d 的大作中提到】
: 在学校里写程序，别人越读不懂，就越有自豪感。
: 在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
【在 O*******d 的大作中提到】
: 在学校里写程序，别人越读不懂，就越有自豪感。
: 在公司里写程序，写得别人读不懂，公司里的大牛会让你重写。
z*e
103 楼
我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
【在 h*****0 的大作中提到】
: 本来就应该写得容易懂。
: 能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
【在 h*****0 的大作中提到】
: 本来就应该写得容易懂。
: 能写出容易懂的代码，能读懂难懂的代码才是牛人，而不是反过来。
O*d
104 楼
Big cow to be.
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
a*l
105 楼
能保证自己写的东西别人很容易看懂就是一个小牛了.
【在 O*******d 的大作中提到】
: Big cow to be.
【在 O*******d 的大作中提到】
: Big cow to be.
O*d
106 楼
Big cow to be, 后备大牛。
【在 a****l 的大作中提到】
: 能保证自己写的东西别人很容易看懂就是一个小牛了.
【在 a****l 的大作中提到】
: 能保证自己写的东西别人很容易看懂就是一个小牛了.
h*0
107 楼
半个牛人。
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
【在 z****e 的大作中提到】
: 我不太能读懂难的代码，但是我写的代码一定都容易懂，我算啥呢？
s*d
108 楼
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
【在 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
109 楼
进位。
【在 s*******d 的大作中提到】
: k < 8 && ++i[k] > 4 是怎么run的？没看明白。。
【在 s*******d 的大作中提到】
: k < 8 && ++i[k] > 4 是怎么run的？没看明白。。
b*n
110 楼
这里不是很明白
可以解释一下为什么i[k++]=from[k]是undefined吗？
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
可以解释一下为什么i[k++]=from[k]是undefined吗？
【在 t****t 的大作中提到】
: (shouldn't use i[k++]=from[k] as it's undefined...)
h*0
111 楼
可以等效成：
i[k] = from [k];
k++;
也可能效果是：
i[k] = from[k + 1];
k++;
【在 b*********n 的大作中提到】
: 这里不是很明白
: 可以解释一下为什么i[k++]=from[k]是undefined吗？
i[k] = from [k];
k++;
也可能效果是：
i[k] = from[k + 1];
k++;
【在 b*********n 的大作中提到】
: 这里不是很明白
: 可以解释一下为什么i[k++]=from[k]是undefined吗？
r*o
112 楼
我现在很喜欢把超过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; //不用进位，所以结束了。
: }
: }
不过我想知道，改写之后除了循环次数少了之后还有什么其他好处吗？
我想来想去，好像就感觉代码量少了些，好像效率没有大的提高?
大牛们怎么看这个问题？
是不是循环次数少了会导致效率高点呢？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
113 楼
呵呵，想起我高中时写Basic程序，写过这样的code。
"好像效率没有大的提高"：一般来说，效率要比原来稍低一些（假设C编程），因为循
环变量用i[0], i[1], i[2]等，比用i0, i1, i2的overhead大一点。主要的好处是灵活
，因为数组的长度可以做成可变的，这样做N层循环时，N不必是一个常数。
【在 r****o 的大作中提到】
: 我现在很喜欢把超过3层循环的code都用这种方法改写，这样用2层循环就够了。
: 不过我想知道，改写之后除了循环次数少了之后还有什么其他好处吗？
: 我想来想去，好像就感觉代码量少了些，好像效率没有大的提高?
: 大牛们怎么看这个问题？
: 是不是循环次数少了会导致效率高点呢？Cache? 流水线？并行
: 欢迎拍砖。
"好像效率没有大的提高"：一般来说，效率要比原来稍低一些（假设C编程），因为循
环变量用i[0], i[1], i[2]等，比用i0, i1, i2的overhead大一点。主要的好处是灵活
，因为数组的长度可以做成可变的，这样做N层循环时，N不必是一个常数。
【在 r****o 的大作中提到】
: 我现在很喜欢把超过3层循环的code都用这种方法改写，这样用2层循环就够了。
: 不过我想知道，改写之后除了循环次数少了之后还有什么其他好处吗？
: 我想来想去，好像就感觉代码量少了些，好像效率没有大的提高?
: 大牛们怎么看这个问题？
: 是不是循环次数少了会导致效率高点呢？Cache? 流水线？并行
: 欢迎拍砖。
m*t
114 楼
我觉得这个才应该被贴出来。前面把一堆东西挤在一行又没有改变复杂度。。。 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; //不用进位，所以结束了。
: }
: }
'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
115 楼
不懂为啥用数组就会效率稍低？
另外，循环层数低了，是不是从cache的角度来讲会效率稍微高些？
【在 d***a 的大作中提到】
: 呵呵，想起我高中时写Basic程序，写过这样的code。
: "好像效率没有大的提高"：一般来说，效率要比原来稍低一些（假设C编程），因为循
: 环变量用i[0], i[1], i[2]等，比用i0, i1, i2的overhead大一点。主要的好处是灵活
: ，因为数组的长度可以做成可变的，这样做N层循环时，N不必是一个常数。
另外，循环层数低了，是不是从cache的角度来讲会效率稍微高些？
【在 d***a 的大作中提到】
: 呵呵，想起我高中时写Basic程序，写过这样的code。
: "好像效率没有大的提高"：一般来说，效率要比原来稍低一些（假设C编程），因为循
: 环变量用i[0], i[1], i[2]等，比用i0, i1, i2的overhead大一点。主要的好处是灵活
: ，因为数组的长度可以做成可变的，这样做N层循环时，N不必是一个常数。
d*a
116 楼
i, j, k这样的循环变量，一般就直接用寄存器了，循环变量的访问不牵涉到内存。用
数组式的循环变量，就要访问内存了。对这个数组的访问，还要用一个循环变量。
只有几层的循环层数，用不用数组，对cache没什么影响。源代码看上去大了不少，似
乎要多占cache，但实际上，机器代码只多一点（每层多两条或三条机器指令）。
【在 r****o 的大作中提到】
: 不懂为啥用数组就会效率稍低？
: 另外，循环层数低了，是不是从cache的角度来讲会效率稍微高些？
数组式的循环变量，就要访问内存了。对这个数组的访问，还要用一个循环变量。
只有几层的循环层数，用不用数组，对cache没什么影响。源代码看上去大了不少，似
乎要多占cache，但实际上，机器代码只多一点（每层多两条或三条机器指令）。
【在 r****o 的大作中提到】
: 不懂为啥用数组就会效率稍低？
: 另外，循环层数低了，是不是从cache的角度来讲会效率稍微高些？
s*V
117 楼
这个就是 几进制吧， 如果是1-4 就是4进制。从 1111 遍历到 4444.
r*o
118 楼
像下面这样的多层循环是不是也有一个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，但实际上，机器代码只多一点（每层多两条或三条机器指令）。
, 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
119 楼
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++)
: {
: }
=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
120 楼
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;
}
#include
#include
using namespace std;
void do_something(const vector
{
cout << "do_something with loop variables: ";
for (auto& i: vars)
cout << i << " ";
cout << endl;
}
void myLoop(vector
{
do_something(vars);
}
template
void myLoop(vector
{
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
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
121 楼
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;
}
't work. The only way I can think of is recursion:
#include
#include
using namespace std;
void do_something(const vector
{
cout << "do_something with loop variables: ";
for (auto& i: vars)
cout << i << " ";
cout << endl;
}
// method 2:
void myLoop(const vector
{
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
{
if (inputs.size() != 0) {
vector
myLoop(inputs, vars);
}
}
int main()
{
cout << "using recursive function" << endl;
vector
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;
}
相关阅读
有啥好的optimization的c/c++库可以用问题请教semiconductor process engineer在哪里可以找到08年国际会议的列表？又到十字路口，何去何从？ (转载)写硕士学位论文要不要必须用latex？ (转载)喉一嗓子，有没有找 electric power 方面工作的！请问一个Control方向会议投稿的一个问题请问，什么是meander fork structure？Poisson/Markov ON-OFF的Traffic是不是属于Gaussian分布的？哪里网购教科书比较便宜？金石GG 诚觅 玉玦MMN个互不相关的随机变量之和的概率问题大家帮忙看看这个offertreadmill 为什么不能用插线板(power strip)外行请教OPC与LabVIEW一个关于用origin处理数据的问题UT Austin 的请进[请教] Quality assurance engineering就业前景如何？请教一个貌似naive的阻抗匹配问题博士论文的写法？