l***y
发帖数: 4671 | 1 为了避免 copy 大数组 (实际运算是 1000-by-1000，并且大量重复访问)，想用个指针
来指向它。
int main () {
static int A[10][10][10];
static int B[10][10][10];
static int C[10][10][10];
A[1][2][3] = 123;
B[1][2][3] = 1230;
C[1][2][3] = 12300;
int (*p)[10][10][10]; // line a
char cFlag;
cin >> cFlag;
while (cFlag == 'A' || cFlag == 'B' ||cFlag == 'C') {
switch (cFlag) {
case 'A':
p = &A;
break;
case 'B':
p = &B;
break;
case 'C':
p = &C;
break;
}
printf("(*p)[1][2][3]: %d\n",(*p)[1][2][3]);
cin >> cFlag;
}
return 0;
}
想请教一下，在 line a 有没有给 p 分配一个 10^3 * sizeof(double) 的空间？还是
1 * sizeof(double)？还是别的？多谢多谢！ |
t****t
发帖数: 6806 | 2 p is only a pointer. after line a, the value of p is indetermined.
【在 l***y 的大作中提到】
: 为了避免 copy 大数组 (实际运算是 1000-by-1000，并且大量重复访问)，想用个指针
: 来指向它。
: int main () {
: static int A[10][10][10];
: static int B[10][10][10];
: static int C[10][10][10];
: A[1][2][3] = 123;
: B[1][2][3] = 1230;
: C[1][2][3] = 12300;
: int (*p)[10][10][10]; // line a
|
X****r
发帖数: 3557 | 3 在line a给p这个变量本身(而不是p指向的内容)在栈上“分配”了大小为sizeof(int (
*)[10][10][10])的空间。
【在 l***y 的大作中提到】
: 为了避免 copy 大数组 (实际运算是 1000-by-1000，并且大量重复访问)，想用个指针
: 来指向它。
: int main () {
: static int A[10][10][10];
: static int B[10][10][10];
: static int C[10][10][10];
: A[1][2][3] = 123;
: B[1][2][3] = 1230;
: C[1][2][3] = 12300;
: int (*p)[10][10][10]; // line a
|
l***y
发帖数: 4671 | 4 多谢！
【在 t****t 的大作中提到】
: p is only a pointer. after line a, the value of p is indetermined.
|
l***y
发帖数: 4671 | 5 好，我这就去查查看。
(
【在 X****r 的大作中提到】
: 在line a给p这个变量本身(而不是p指向的内容)在栈上“分配”了大小为sizeof(int (
: *)[10][10][10])的空间。
|
m*********t
发帖数: 527 | 6 乃最好别这么写，[10]x[10]x[10] 的矩阵还好说，要是更大的可能直接导致 stack
overflow。。。。。。比如你试试 改成 500 x 500 x 500。。。。 |
l***y
发帖数: 4671 | 7 结果：
sizeof(int(*)[1000][1000][1000]): 8
sizeof(double(*)[1000][1000][1000]): 8
sizeof (int(*)): 8
sizeof (double(*)): 8
【在 l***y 的大作中提到】
: 好，我这就去查查看。
:
: (
|
l***y
发帖数: 4671 | 8 对了哈，要想 double[500][500][500] 该咋办？在 Linux 上。
【在 m*********t 的大作中提到】
: 乃最好别这么写，[10]x[10]x[10] 的矩阵还好说，要是更大的可能直接导致 stack
: overflow。。。。。。比如你试试 改成 500 x 500 x 500。。。。
|
b***i
发帖数: 3043 | 9 传统的方法是
int** ary = new int*[sizeX];
for(int i = 0; i < sizeX; ++i)
ary[i] = new int[sizeY];
参考
http://stackoverflow.com/questions/936687/how-do-i-declare-a-2d
【在 l***y 的大作中提到】
: 对了哈，要想 double[500][500][500] 该咋办？在 Linux 上。
|
l***y
发帖数: 4671 | 10 多谢哈。我是在想，有没有可能把 linux 的某个系统变量改一下。简略 google 了一
下，没找到。。。
【在 b***i 的大作中提到】
: 传统的方法是
: int** ary = new int*[sizeX];
: for(int i = 0; i < sizeX; ++i)
: ary[i] = new int[sizeY];
: 参考
: http://stackoverflow.com/questions/936687/how-do-i-declare-a-2d
|
|
|
X****r
发帖数: 3557 | 11 No, that's not a 2-D array, but an 1-D array of pointers, each
points to the first elements of 1-D arrays. Why don't you directly
allocate a 2-D array? e.g. for double [500][500],
double (*a)[500] = new double[500][500];
// access a[x][y]
delete[] a;
【在 b***i 的大作中提到】
: 传统的方法是
: int** ary = new int*[sizeX];
: for(int i = 0; i < sizeX; ++i)
: ary[i] = new int[sizeY];
: 参考
: http://stackoverflow.com/questions/936687/how-do-i-declare-a-2d
|
l***y
发帖数: 4671 | 12 。。。 C++ 有真正意义上的多维数组么？记得好像只有一维数组，其它各维都是指向
上一维的一维指针数组。
对了，再请教一下快速初始化大的多维数组为非零值的问题。
第一个问题：数组初始化为 0 可以简单 memset，但是非零值呢？比如说初始化为某个
变量 x 的值。用多重循环是惊人的慢啊。
另一个问题，初始化数组时，如果用 double A[500][500] = {{0}}; 是不是实际执行
的是 memset？貌似这种句式只能设 {{0}}，其它的值不管用。
多谢多谢！
【在 X****r 的大作中提到】
: No, that's not a 2-D array, but an 1-D array of pointers, each
: points to the first elements of 1-D arrays. Why don't you directly
: allocate a 2-D array? e.g. for double [500][500],
: double (*a)[500] = new double[500][500];
: // access a[x][y]
: delete[] a;
|
t****t
发帖数: 6806 | 13 理论上来说, 只有数组这一种东西, 也就是你理解的"一维"数组. 但是除了指针数组以
外, 也有数组的数组. 这两个东西完全不同, 但是引用起来都是x[i][j]这样的写法.
多重循环不知道有什么慢的, memset其实本质上也是循环, 或许有利用CPU指令的优化,
但是数量级上并无区别.
只能设0. 如果不设0则不能省略.
【在 l***y 的大作中提到】
: 。。。 C++ 有真正意义上的多维数组么？记得好像只有一维数组，其它各维都是指向
: 上一维的一维指针数组。
: 对了，再请教一下快速初始化大的多维数组为非零值的问题。
: 第一个问题：数组初始化为 0 可以简单 memset，但是非零值呢？比如说初始化为某个
: 变量 x 的值。用多重循环是惊人的慢啊。
: 另一个问题，初始化数组时，如果用 double A[500][500] = {{0}}; 是不是实际执行
: 的是 memset？貌似这种句式只能设 {{0}}，其它的值不管用。
: 多谢多谢！
|
l***y
发帖数: 4671 | 14 能展开讲讲数组的数组么？一直理解为一维数组名本身就是指针，所以数组的数组本身
就是个一维的指针的数组。
刚测过，memset 和多重循环比起来的确是一个数量级，不开 -O3 时差别大约三倍，打
开 -O3 后 loop 比 memset 更快。但是在我的实际 code 里，memset 比 loop 大概要
快两个数量级 -- 天知道怎么回事。。。
double A[1000][1000] = {{0}};
clock_t t_start = -1;
t_start = clock();
for (int ind = 0; ind < 1000; ind++)
for (int i = 0; i < 1000; i++)
for (int j = 0; j < 1000; j++)
A[i][j] = 0;
t_start = clock() - t_start;
printf("Loop takes %f sec; ", t_start/(double)(CLOCKS_PER_SEC));
t_start = clock();
for (int ind = 0; ind < 1000; ind++)
memset(A,0,1000*1000*sizeof(double));
t_start = clock() - t_start;
printf("memset() takes %f sec. \n", t_start/(double)(CLOCKS_PER_SEC));
$ g++ -Wall -std=c++0x test.cpp -o a
$ ./a
Loop takes 6.170000 sec; memset() takes 2.200000 sec.
$ g++ -Wall -std=c++0x test.cpp -O3 -o a
$ ./a
Loop takes 1.800000 sec; memset() takes 2.190000 sec.
$ ./a
Loop takes 1.680000 sec; memset() takes 2.080000 sec.
化,
【在 t****t 的大作中提到】
: 理论上来说, 只有数组这一种东西, 也就是你理解的"一维"数组. 但是除了指针数组以
: 外, 也有数组的数组. 这两个东西完全不同, 但是引用起来都是x[i][j]这样的写法.
: 多重循环不知道有什么慢的, memset其实本质上也是循环, 或许有利用CPU指令的优化,
: 但是数量级上并无区别.
: 只能设0. 如果不设0则不能省略.
|
X****r
发帖数: 3557 | 15 数组和指针是两回事。
比如int a[10];定义了一个有10个int元素的数组，sizeof(a) == sizeof(int) * 10
而int *p;定义了一个指向一个int的指针，sizeof(p) == sizeof(int*)
之所以会有数组就是指针的混淆是因为int [10]类型可以自动转换成int *类型，这种
转换被称为array-to-pointer conversion，所有左值(lvalue)表达式作为右值
(rvalue)使用的时候都要经过这种转换，而转换结果就是指向该数组首元素的指针，
所以a的值就相当于&a[0]，但是即使赋值p=a也不能认为它们是一回事，比如
&a和&p的类型和值就完全不同，因为这里&a并不是将a当作右值来用所以array-to-
pointer
conversion不适用。
数组的数组就是字面上的意义：一个数组的每个元素都是数组。
比如int a2[5][10];定义了一个有5个int [10]元素的数组，sizeof(a2) ==
sizeof(int [10]) * 5，即sizeof(int) * 10 * 5
而指针数组int *pa[5];定义了一个有5个int *元素的数组，sizeof(pa) ==
sizeof(int *) * 5，具体它的那些元素指向何处需要另行初始化，于二维数组完全不
同。
【在 l***y 的大作中提到】
: 能展开讲讲数组的数组么？一直理解为一维数组名本身就是指针，所以数组的数组本身
: 就是个一维的指针的数组。
: 刚测过，memset 和多重循环比起来的确是一个数量级，不开 -O3 时差别大约三倍，打
: 开 -O3 后 loop 比 memset 更快。但是在我的实际 code 里，memset 比 loop 大概要
: 快两个数量级 -- 天知道怎么回事。。。
: double A[1000][1000] = {{0}};
: clock_t t_start = -1;
: t_start = clock();
: for (int ind = 0; ind < 1000; ind++)
: for (int i = 0; i < 1000; i++)
|
b***i
发帖数: 3043 | 16 楼主问多维数组，他总有一天会用到几个维的大小都是动态的数组。指针的数组可以完
成动态分配多维数组，否则只有一维可以变大小。
另一个办法是用vector。
【在 X****r 的大作中提到】
: No, that's not a 2-D array, but an 1-D array of pointers, each
: points to the first elements of 1-D arrays. Why don't you directly
: allocate a 2-D array? e.g. for double [500][500],
: double (*a)[500] = new double[500][500];
: // access a[x][y]
: delete[] a;
|
