还是关于const的有关问题
还是关于const的问题？
有一个数组：
int * a[5][6]; //二维数组，元素为整型指针
要定义一个函数对该数组只做读取操作，所以想到用const修饰。
void f(const * p[5][6]){...}
编译不过，说无法将int *[5][6]类型转换成const int *[5][6]类型。
本来是想把p定义成二维数组，元素为指向整型常量的指针，所以在函数f中不会修改数组元素实际指向的值。
既然这样定义不行，各位高人想个方法怎样定义达到上述要求啊。
如果定义void f(const * const p[5][6]){...},可以通过，但不是愿意。
------解决方案--------------------
void f(int * const p[5][6]){...}
------解决方案--------------------
你把基本的类型丢了~故错
------解决方案--------------------
void f( int* const(*m)[6] )
{
for (int i=0;i <5;++i)
{
for (int j=0;j <6;j++)
{
cout < <m[i][j] < < " ";
//m[i][j]=0; //Error: l-value specifies const object.
}
cout < <endl;
}
cout < <endl;
}
int main()
{
int* a[5][6];
for (int i=0;i <5;++i)
{
for (int j=0;j <6;++j)
{
a[i][j]=(int*)(i*6+j);
}
}
f(a);
return 0;
}
------解决方案--------------------
taodm是对的：void f(int * const p[5][6]){...}
数组p[5][6]的元素不能被修改
------解决方案--------------------
那就指针类型强转呀。
------解决方案--------------------
taodm能不能详细说一下如何强制类型转换呢？我强转了，不行
typedef const int * const tp[][6];
int f(tp)
{
return 0;
}
int main(int argc, char* argv[])
{
int i=10;
int *pd[5][6];
f((const int * const [][6])pd);//cannot convert from 'int *[5][6] ' to 'const int *const [][6]
f((tp)pd)//cannot convert from 'int *[5][6] ' to 'const int *const [][6]
printf( "Hello World!\n ");
return 0;
}
不知道有什么问题？
------解决方案--------------------
好像有一个const的强制转换的,一共四个，搜一下 const_cast??
------解决方案--------------------
看了下面得解释我才明白为什么没有默认转换了
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
为了防止指针指向的常量被修改，C标准对于指针间赋值有一个规定，就是左值必须包含右值的所有限定词。这就限定了一个指向const对象的指针不能赋值给指向非const对象的指针，但反过来就允许。这个规定初看上去非常合理，但其效用其实只限于一级指针，二级指针间的赋值即使满足规定也不再安全，下面举个例子：
const int i=10;
const int **p1;
int *p2;
p1 = &p2;
*p1 = &i;
*p2 = 20;
现在你会发现，作为常量的i的值被修改了。i的值被修改的关键原因在*p1=&i;这一句，&i是一个指向常量的一级地址，如果没有二级指针p1，受限于上述规定，作为左值接受这个一级地址的指针就必须也是一个指向常量的一级指针，于是就不能进行下一步赋值20的操作。因此，正由于指向 const对象的二级指针p1的出现，使得*p1也是一个指向const的指针，于是*p1=&i能够合法地运行，常量i的值被修改也就成了一个预想中的结果了。有鉴于此，某些编译器也会限定非const二级指针之间的赋值，规定上面的p1=&p2也是非法的。
http://blog.chinaunix.net/u1/35334/showart_301547.html
------解决方案--------------------
按楼上的
int main(int argc, char* argv[])
{
const int i=10;
const int **p1;
int *p2;
p1 = (const int **)&p2;
*p1 = &i;
*p2 = 20;
cout < <i < <endl;
printf( "%d\n ",j);
return 0;
}
输出居然是10，但是在调试器中能看到i=20...
谁能解释啊？
------解决方案--------------------
对于非法的操作就不要期望有任何合理的结果了
------解决方案--------------------
typedef const int * const (*tp)[6];
有一个数组：
int * a[5][6]; //二维数组，元素为整型指针
要定义一个函数对该数组只做读取操作，所以想到用const修饰。
void f(const * p[5][6]){...}
编译不过，说无法将int *[5][6]类型转换成const int *[5][6]类型。
本来是想把p定义成二维数组，元素为指向整型常量的指针，所以在函数f中不会修改数组元素实际指向的值。
既然这样定义不行，各位高人想个方法怎样定义达到上述要求啊。
如果定义void f(const * const p[5][6]){...},可以通过，但不是愿意。
------解决方案--------------------
void f(int * const p[5][6]){...}
------解决方案--------------------
你把基本的类型丢了~故错
------解决方案--------------------
void f( int* const(*m)[6] )
{
for (int i=0;i <5;++i)
{
for (int j=0;j <6;j++)
{
cout < <m[i][j] < < " ";
//m[i][j]=0; //Error: l-value specifies const object.
}
cout < <endl;
}
cout < <endl;
}
int main()
{
int* a[5][6];
for (int i=0;i <5;++i)
{
for (int j=0;j <6;++j)
{
a[i][j]=(int*)(i*6+j);
}
}
f(a);
return 0;
}
------解决方案--------------------
taodm是对的：void f(int * const p[5][6]){...}
数组p[5][6]的元素不能被修改
------解决方案--------------------
那就指针类型强转呀。
------解决方案--------------------
taodm能不能详细说一下如何强制类型转换呢？我强转了，不行
typedef const int * const tp[][6];
int f(tp)
{
return 0;
}
int main(int argc, char* argv[])
{
int i=10;
int *pd[5][6];
f((const int * const [][6])pd);//cannot convert from 'int *[5][6] ' to 'const int *const [][6]
f((tp)pd)//cannot convert from 'int *[5][6] ' to 'const int *const [][6]
printf( "Hello World!\n ");
return 0;
}
不知道有什么问题？
------解决方案--------------------
好像有一个const的强制转换的,一共四个，搜一下 const_cast??
------解决方案--------------------
看了下面得解释我才明白为什么没有默认转换了
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
为了防止指针指向的常量被修改，C标准对于指针间赋值有一个规定，就是左值必须包含右值的所有限定词。这就限定了一个指向const对象的指针不能赋值给指向非const对象的指针，但反过来就允许。这个规定初看上去非常合理，但其效用其实只限于一级指针，二级指针间的赋值即使满足规定也不再安全，下面举个例子：
const int i=10;
const int **p1;
int *p2;
p1 = &p2;
*p1 = &i;
*p2 = 20;
现在你会发现，作为常量的i的值被修改了。i的值被修改的关键原因在*p1=&i;这一句，&i是一个指向常量的一级地址，如果没有二级指针p1，受限于上述规定，作为左值接受这个一级地址的指针就必须也是一个指向常量的一级指针，于是就不能进行下一步赋值20的操作。因此，正由于指向 const对象的二级指针p1的出现，使得*p1也是一个指向const的指针，于是*p1=&i能够合法地运行，常量i的值被修改也就成了一个预想中的结果了。有鉴于此，某些编译器也会限定非const二级指针之间的赋值，规定上面的p1=&p2也是非法的。
http://blog.chinaunix.net/u1/35334/showart_301547.html
------解决方案--------------------
按楼上的
int main(int argc, char* argv[])
{
const int i=10;
const int **p1;
int *p2;
p1 = (const int **)&p2;
*p1 = &i;
*p2 = 20;
cout < <i < <endl;
printf( "%d\n ",j);
return 0;
}
输出居然是10，但是在调试器中能看到i=20...
谁能解释啊？
------解决方案--------------------
对于非法的操作就不要期望有任何合理的结果了
------解决方案--------------------
typedef const int * const (*tp)[6];