谈谈volatile和const

用户:404082727(走尽天涯路)

==================================================
消息组:群/校友录()
==================================================
消息类型:聊天记录
==================================================

2004-12-28 14:50:43 lalala()
const 只是指明后面的变量初始化后不能被赋值。这只是编译时刻的限制。也就是说，
a基本上是一个普通的变量，只是compiler在检查你的代码有没有对它赋值。

在运行时刻，a与别的变量没有区别。

如果int a = i; 合法，const int a = i; 当然合法。因为这样的初始化是在运行时刻
完成的。

const 的值甚至是可以改变的！！！

#include <stdio.h>

int main(int argc, char* argv[])
{
   volatile const int a = 0;

   int* p = (int*) &a;

   *p = 1;

   printf ("*p = %d, a = %d, p = %p, &a = %p, &p = %p/n", *p, a, p, &a, &p);
}

运行结果：（cygwin, gcc)

*p = 1, a = 1, p = 0x22feec, &a = 0x22feec, &p = 0x22fee8

注意：a与p的位置是紧邻的，都在栈里。如果没有volatile，运行结果是：
*p = 1, a = 0, p = 0x22feec, &a = 0x22feec, &p = 0x22fee8

这完全是编译器自己优化的结果

2004-12-28 14:53:17 漫.ASH()
厚厚，const只是在编译期间申明一下而已，不是用来从硬件上使他成为只读的。
所以有很多方法可以骗过编译器。

2004-12-28 14:53:45 曾经未来()
http://blog.csdn.net/kendiv/archive/2004/12/28/231710.aspx
GCC 中文手册

2004-12-28 14:54:20 lalala()
关键是那个volatile,以前没用过

2004-12-28 14:56:07 iCoding()
是不是volatile和const作用相反，等于没加const?[?]

2004-12-28 14:56:45 lalala()
volatile说这个变量可能会被修改，编译器不会用常量去代替它

2004-12-28 14:57:30 iCoding()
volatile说这个变量可能会被修改
---------------
说和没说一样，变量的值当然会被修改了

2004-12-28 14:58:03 iCoding()
http://www.coresoft.com.ru/ibbs/topic.asp?bbsid=2&topicid=25

2004-12-28 14:58:06 走尽天涯路()
他俩没啥关系吧，volatile告诉编译器不要优化变量

2004-12-28 14:58:46 lalala()
常量

2004-12-28 14:59:14 走尽天涯路()
不是常量的意思，

2004-12-28 14:59:25 曾经未来()
unknown & undefine
应该是是什么值呢？

2004-12-28 14:59:45 lalala()
别说我写的，让人笑话，这是我转的

2004-12-28 15:00:00 iCoding()
lalala
const int a = 0;
int* p = (int*) &a;
*p = 1;这样行不行捏？
 

2004-12-28 15:00:14 lalala()
可以

2004-12-28 15:00:18 走尽天涯路()
unknown & undefine
应该是是什么值呢？
说的什么呀
 

2004-12-28 15:00:28 曾经未来()
多元逻辑

2004-12-28 15:00:46 漫.ASH()
不仅不知道，而且未定义

2004-12-28 15:01:26 走尽天涯路()
多元逻辑 指的哪些东西啊

2004-12-28 15:01:46 iCoding()
那就volatile没多大关系，只不过在骗编译器而已，编译器不知道p指向的是啥[;P]

2004-12-28 15:03:08 lalala()
int main(int argc, char *argv[])
{
  const int a = 0;
int* p = (int*) &a;
*p = 1;
cout<<a<<endl;
cout<<*p<<endl;
    system("PAUSE");
    return 0;
}
 

2004-12-28 15:03:15 lalala()
输出0，1
 

2004-12-28 15:03:36 漫.ASH()
糟糕的编程风格

2004-12-28 15:04:04 lalala()
int main(int argc, char *argv[])
{
  volatile const int a = 0;
int* p = (int*) &a;
*p = 1;
cout<<a<<endl;
cout<<*p<<endl;
    system("PAUSE");
    return 0;
}

2004-12-28 15:04:10 lalala()
就是1，1了

2004-12-28 15:04:22 lalala()
有了volatile

2004-12-28 15:04:28 漫.ASH()
只要用了强制转换，任何const灰都没用啊

2004-12-28 15:04:45 lalala()
就是1，1了

2004-12-28 15:04:46 iCoding()
[;@]怎么会这样啊？

2004-12-28 15:04:52 lalala(3)
const只能防你不小心

2004-12-28 15:04:59 iCoding(5)
NND...我来试试

2004-12-28 15:05:33 lalala()
你专门去改，当然能改得了

2004-12-28 15:07:10 Ricky(1)
我记得前段时间在群里面和一个网友讨论过

2004-12-28 15:07:48 lalala()
我也看了，说得是第一种情况输出0，1的

2004-12-28 15:07:57 iCoding()
没听到...

2004-12-28 15:08:42 lalala()
就是没加volatile的那种情况，编译器把常量用立即数替换了

2004-12-28 15:09:07 Ricky()
这里可以说是volatile的一种滥用

2004-12-28 15:09:11 走尽天涯路()
volatile类型的限定词,它告诉编译器，变量可以被应用程序本身以外的某个东西进行修改，这些东西包括操作系统，硬件或同时执行的线程等。尤其是，volatile限定词会告诉编译器，不要对该变量进行任何优化，并且总是重新加载来自该变量的内存单元的值。 
 

2004-12-28 15:09:54 unfeng()
volatile只是对编译器的一种暗示，
 

2004-12-28 15:10:00 iCoding()
 const int i=1;
 int *p=(int *)&i;
 cout<<i<<endl;
 cout<<*p<<endl;

2004-12-28 15:10:16 iCoding()
程序输出：
1
1

2004-12-28 15:10:23 iCoding()
昏

2004-12-28 15:10:34 漫.ASH()
有什么晕的？

2004-12-28 15:10:42 lalala()
你没改，

2004-12-28 15:10:53 iCoding()
没修改指针指向值

2004-12-28 15:10:56 Ricky()
当一个变量被定义成const，是否已经在暗示编译器：我不想改变这个变量，既然是如此，我还用volatile去修饰……所以我觉得是滥用了

2004-12-28 15:11:04 lalala()
const int a = 0;
int* p = (int*) &a;
*p = 1;

2004-12-28 15:11:28 漫.ASH()
这样做说明了什么？

2004-12-28 15:11:31 lalala()
你是说发明volatile是脱裤子放屁？

2004-12-28 15:11:55 iCoding()
1
2

2004-12-28 15:12:08 iCoding()
 const int i=1;
 int *p=(int *)&i;
 *p=2;
 cout<<i<<endl;
 cout<<*p<<endl;

2004-12-28 15:12:34 Ricky(1)
当然不是，在多线程编程中，为了避免错误的优化，是需要的

2004-12-28 15:13:13 lalala()
就是这个：volatile限定词会告诉编译器，不要对该变量进行任何优化，并且总是重新加载来自该变量的内存单元的值。 
 

2004-12-28 15:13:23 lalala()
我们用了他这个特性

2004-12-28 15:13:26 漫.ASH()
明显滥用了啊，本来就是const常量的东西，你还对编译器说不要优化，有什么意思捏？
不过用在类里头到值得商榷啊？？？
是不是可以让某个mutable的变量不被优化捏？

2004-12-28 15:13:42 Ricky()
nod，这就是我说的滥用

2004-12-28 15:14:28 漫.ASH()
不过用在类里头到值得商榷啊？？？
是不是可以让某个mutable的变量不被优化捏？
是不是呢？

2004-12-28 15:15:08 Ricky()
ASH请说明一下

2004-12-28 15:15:11 lalala()
不知道正常使用volatile的情况，没碰到过，哪位举个例子

2004-12-28 15:16:06 漫.ASH()
比如一个常量对象里的可变属性，对他用volatile，有意义吗？

 
2004-12-28 15:18:31 lalala()
(漫.ASH) 15:16:06
比如一个常量对象里的可变属性，对他用volatile，有意义吗？

 

是反问吗？
 

2004-12-28 15:18:44 漫.ASH()
疑问

2004-12-28 15:19:20 曾经未来()
我还真没研究过，一般我看到这种东西都跳过的

2004-12-28 15:19:25 lalala(3)
既然是常量对象了怎么还会有可变属性

2004-12-28 15:19:55 曾经未来()
C++不是Java，想要灵活，就不可能不在安全上付出代价

2004-12-28 15:19:58 Ricky()
mutable不就是可变属性吗？

2004-12-28 15:20:00 Ricky()
刚刚在CSDN上看到一段文字，正在消化中

2004-12-28 15:20:01 漫.ASH()
当然有了

2004-12-28 15:20:12 lalala()
贴出来看看

2004-12-28 15:20:09 iCoding()
我就搬起石头砸自己脚了mad

2004-12-28 15:24:56 Ricky()
4.谈谈volatile和”完全const对象”
  一个有volatile修饰的类只允许访问其接口的一个子集，这个子集由类的
  实现者来控制.用户只有用const_cast才可以访问这个类型的全部接口.而且,
  象const一样，类的volatile属性会传递给它的成员.想象const修饰的对
  象,它的成员变量是不可修改的,而它通过指针维护的对象或原生变量是可
  修改.那么我们想:如果对象维护一个char* ,则它相当于char*
  const chrptr ;而不是const char* cosnt chrptr;对于类中的指针你需要
  这样修饰以防止它或它维护的资源：cosnt x* xptr;而不是x*const xptr;
  因为cosnt 修饰的对象它默认 的行为是延续变量：x* cosnt xptr;

  更重要的,volatile修饰的数据,编译器不可对其进行执行期寄存于寄存器的优化.
  这种特性,是为了多线程同步的需要.有兴趣者看参看Andrei的GP系列文章.

http://www.chinaunix.net/jh/23/94481.html

 

2004-12-28 15:26:12 Ricky()
关于volatile关键字的说明以及测试:
http://blog.vckbase.com/iwaswzq/archive/2004/12/05/1896.aspx

2004-12-28 15:26:38 Ricky()
上次也是和lalala讨论过const问题的吧？

2004-12-28 15:26:58 lalala()
我是跟你学习，呵呵

2004-12-28 15:27:11 lalala(3)
我是跟你学习，呵呵

2004-12-28 15:27:14 Ricky()
一起学习

2004-12-28 15:27:49 iCoding()
虚怀若谷啊....偶PF哦

2004-12-28 15:28:32 Ricky()
少笑话我就ok了

2004-12-28 15:29:31 iCoding()
哪有？谁敢笑话跳出来~~~~~

没有吗？没有吗？

哦，真滴没有.....

2004-12-28 15:29:45 iCoding()
ohh

2004-12-28 15:31:13 iCoding()
不过我觉得还是C语言的转换方法更容易懂一点，C++的const_cast<>我就搞不明白...

2004-12-28 15:32:11 Ricky()
C的转换方式可以少输入几个字母，这是我很欣赏的一点，否则我还是使用const_cast<>

2004-12-28 15:32:39 lalala()
26367948(漫.ASH) 15:16:06
比如一个常量对象里的可变属性，对他用volatile，有意义吗？

链接给我看看好吗
 

2004-12-28 15:32:56 iCoding()
ASH走人啦~~~

 

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

关于volatile关键字的说明以及测试

作者：九月鹰飞

　　volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

使用该关键字的例子如下：

int volatile nVint;

　　当要求使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。

例如：

volatile int i=10;
int a = i;
...
//其他代码，并未明确告诉编译器，对i进行过操作

int b = i;

　　volatile 指出 i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在b中。而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在b中。而不是重新从i里面读。这样以来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问。
　　注意，在vc6中，一般调试模式没有进行代码优化，所以这个关键字的作用看不出来。下面通过插入汇编代码，测试有无volatile关键字，对程序最终代码的影响：
　　首先，用classwizard建一个win32 console工程，插入一个voltest.cpp文件，输入下面的代码：
　

#include <stdio.h>
void main()
{
	int i=10;
	int a = i;
	
	printf("i= %d/n",a);
	//下面汇编语句的作用就是改变内存中i的值，但是又不让编译器知道
	__asm {
		mov dword ptr [ebp-4], 20h
	}
	
	int b = i;
	printf("i= %d/n",b);
}      

然后，在调试版本模式运行程序，输出结果如下：

i = 10
i = 32

然后，在release版本模式运行程序，输出结果如下：

i = 10
i = 10

输出的结果明显表明，release模式下，编译器对代码进行了优化，第二次没有输出正确的i值。下面，我们把 i的声明加上volatile关键字，看看有什么变化：

#include <stdio.h>
void main()
{
	volatile int i=10;
	int a = i;
	
	printf("i= %d/n",a);
	__asm {
		mov dword ptr [ebp-4], 20h
	}
	
	int b = i;
	printf("i= %d/n",b);
}      

分别在调试版本和release版本运行程序，输出都是：

i = 10
i = 32

这说明这个关键字发挥了它的作用！
iwaswzq 于2004/12/4/16:15：http://www.vckbase.com/document/viewdoc/?id=1312