我有一篇文章,但我失去了它.它展示并描述了一些人们应该小心的C/C++技巧.其中一个让我感兴趣,但现在我正在尝试复制它,我无法将其编译.
这个概念是可以随意改变constC/C++ 中a的值
它是这样的:
const int a = 3; // I promise I won't change a
const int *ptr_to_a = &a; // I still promise I won't change a
int *ptr;
ptr = ptr_to_a;
(*ptr) = 5; // I'm a liar; a is now 5
我想向朋友展示这个,但现在我错过了一步.有谁知道它开始编译和工作缺少什么？
ATM我从'const int*'到'int*'的转换无效,但是当我读到我试过的文章时,它运行得很好.
我试图更改一个变量的值,该变量定义为int const,如下所示.
const int w = 10;
int* wp = const_cast <int*> (&w);
*wp = 20;
w的值没有改变,即使在赋值之后仍然是10,尽管它表明w和wp都指向同一个内存位置.但是我可以更改w的值,如果在声明时定义如下
int i = 10;
const int w = i;
如果我改变i的声明使其成为常量
const int i = 10;
w的值不会改变.
在第一种情况下,为什么w的值没有改变,即使w和wp指向相同的内存位置[这是我打印地址时的印象]
与编译器有什么不同,它以不同的方式处理这两种情况？
有没有办法确保w不会失去常数,无论它的定义方式如何？
#include <iostream>
using namespace std;
int main() {
const int N = 22;
int * pN = const_cast<int*>(&N);
*pN = 33;
cout << N << '\t' << &N << endl;
cout << *pN << '\t' << pN << endl;
}
22 0x22ff74
33 0x22ff74
为什么同一地址有两个不同的值？
我应该确定此函数在语法上是否正确：
int f3(int i, int j) { const int& k=i; ++i; return k; }
我已经对其进行了测试，并且可以使用我的主要功能进行编译。
我不明白为什么会这样。
通过调用函数，可以肯定地f3创建变量的副本，i并j在新的存储空间中进行设置const int& k=i，然后将新创建k的存储空间设置为与复制的存储空间完全相同的空间i，因此可以进行任何更改，即增量鉴于已设置，++i将导致++k无法执行const
任何帮助是极大的赞赏
是否const通过constC标准允许的声明访问非对象？例如,以下代码保证在符合标准的平台上编译和输出23和42？
翻译单位A:
int a = 23;
void foo(void) { a = 42; }
翻译单位B:
#include <stdio.h>
extern volatile const int a;
void foo(void);
int main(void) {
printf("%i\n", a);
foo();
printf("%i\n", a);
return 0;
}
在ISO/IEC 9899:1999中,我刚刚发现(6.7.3,第5段):
如果尝试通过使用具有非const限定类型的左值来修改使用const限定类型定义的对象,则行为是未定义的.
但在上面的例子中,对象没有定义为const(但只是声明).
UPDATE
我终于在ISO/IEC 9899:1999中找到了它.
6.2.7,2
引用同一对象或函数的所有声明都应具有兼容类型; 否则,行为未定义.
6.7.3,9
要使两种合格类型兼容,两者都应具有相同类型的兼容类型; [...]
所以,它是未定义的行为.
从这篇文章.
对于变量声明为另一个用途
register,并const是抑制该变量的任何非本地的改变,甚至槽利用其地址,然后浇铸指针.即使你认为自己永远不会这样做,一旦你将一个指针(即使有一个const属性)传递给其他函数,你也永远无法确定这可能是恶意的并且改变你脚下的变量.
我不明白我们如何const通过指针修改变量的值.是不是未定义的行为？
const int a = 81;
int *p = (int *)&a;
*p = 42; /* not allowed */
我正在通过面试问题向初级C++开发人员的位置看.问题是(引用):
以下代码是否正确？
struct Foo
{
int i;
void foo ( void ) const
{
Foo* pointer = const_cast<Foo*>(this);
pointer->i = 0;
}
};
我会回答:
代码本身根据C++ 03和c ++ 11标准有效,并且将成功编译.但它可能在赋值指针 - > i = 0期间调用未定义的行为; 如果调用foo()的类的实例声明为const.
我的意思是下面的代码将成功编译并导致未定义的行为.
struct Foo
{
int i;
Foo ( void )
{
}
void foo ( void ) const
{
Foo* pointer = const_cast<Foo*>(this);
pointer->i = 0;
}
};
int main ( void )
{
Foo foo1;
foo1.foo(); …以下示例在我的理解中增加了混乱.我无法理解如何修改const变量local.请帮我理解一下.
/* Compile code without optimization option */
// volatile.c
#include <stdio.h>
int main(void)
{
const int local = 10;
int *ptr = (int*) &local;
printf("Initial value of local : %d \n", local);
*ptr = 100;
printf("Modified value of local: %d \n", local);
return 0;
}
$ gcc volatile.c -o volatile -save-temps
$ ./volatile
本地的初始值:10
修改后的本地值:100
我知道使用const_cast通常是坏主意,但我正在玩它,我遇到了一个奇怪的行为,其中:
两个指针具有相同的地址值,但在取消引用时,给出不同的数据值.
有没有人对此有解释？
码
#include <iostream>
int main()
{
const int M = 10;
int* MPtr = const_cast<int*>(&M);
(*MPtr)++;
std::cout << "MPtr = " << MPtr << " (*MPtr) = " << (*MPtr) << std::endl;
std::cout << " &M = " << &M << " M = " << M << std::endl;
}
产量
MPtr = 0x7fff9b4b6ce0 (*MPtr) = 11
&M = 0x7fff9b4b6ce0 M = 10
以下程序的输出在gcc上为50.怎么可能因为x是常量变量而*p是x本身,因为p是指向x处的值的常量指针.turbo c给编译器错误的地方.这是一个未定义的行为吗？请解释.
#include<stdio.h>
int main()
{
const int x = 25;
int * const p = &x;
*p = 2 * x;
printf("%d", x);
return 0;
}