3815人阅读
一、extern
1)当它与&C&一起连用时，如: extern &C& void fun(int a, int b); 则告诉编译器在编译fun这个函数名时按着C的规则去翻译相应的函数名而不是C++的，因为C++的多态。
2)当extern不与&C&在一起修饰变量或函数时，如在头文件中: extern int g_I 它的作用就是声明函数或全局变量的作用范围的关键字，其声明的函数和变量可以在本模块或者其他模块中使用，记住它是一个声明不是定义!也就是说B模块(编译 单元)要是引用模块(编译单元)A中定义的全局变量或函数时，它只要包含A模块的头文件即可, 在编译阶段，模块B虽然找不到该函数或变量，但它不会报错，它会在连接时从模块A生成的目标代码中找到此函数。只在A中定义一次，在B中就可以使用，在内存中只有一份拷贝，在B中没有实际的空间。
如果在A的头文件中extern char g_str[7] = &123456&; // 这个时候相当于没有extern，也就是写与不写一个效果。
如果B在包含A的头文件，那么会编译报错，因为如果B在包含A的头文件的时候相当于又重新定义了一个g_str的全局变量，相当于两个模块的全局变量重名了。最好的办法就是在头文件中，只声明，不定义extern char g_str[7]；然后在赋值。所以只在头文件中做声明，真理总是这么简单。
二、static
1）如果static变量声明在A头文件中，如果第二个模块B包含A的头文件，那么其实在两个模块中各自有static的一个拷贝，是不同的内存，(只有在B模块中修改这个静态值的时候才分配空间，这就是copy-on-write，与fork时候很像。)值是可以不同的。所以一般用static一般不写在头文件中（声明定义都不在），这样就不会给其他模块造成不必要的信息污染。因为一般编译器会有优化，如果B里面的static值不改变，那么是不必要分配空间的，而是在改变B中static的时候会分配空间。
2）还有两点要特别注意的，static函数必须访问static变量，不管是不是在类中，static变量默认初始为0。
1）一个题目
&&&&&&& const int a = 1;
&&&&&&& int *p = (int *)&a;
&&&&&&& *p = 2;
&&&&&&& cout&&a&&
&&&&&&& cout&&*p&&
输出为1和2.其实如果不访问a的地址，那么a实际是不会分配空间的，如果访问并更改a地址空间的值，那么这个时候就会分配一个空间给a。
2）const如果不和extern一起使用，那么const实际是和static一样的，在每个模块中都有一个const的拷贝。
3）还有就是在类中，每个对象都有一个不同的const值，这个值在对象的生命周期是不变的。
4）const char* g_str = &123456& 与 const char g_str[] = &123465&是不同的， 前面那个const 修饰的是char * 而不是g_str,它的g_str并不是常量，它被看做是一个定义了的全局变量（可以被其他编译单元使用）， 所以如果你像让char *g_str遵守const的全局常量的规则，最好这么定义const char* const g_str=&123456&.
例如&&&&&&&
char str[] = &hello&;
const char *p =//OK，p的意思是，不可以通过p来修改所指向的内容，但是str[0] = 'a';是可以的，所以这个字符串不是常字符串
char str2[] = &world&;
p = str2;//OK，这个时候可以改变p的值
char str[] = &hello&;
char const *p =//OK,但是同样不是个const字符串，而且可以通过p[0] = 'a'来直接修改。
char str2[] = &world&;
p = str2;//编译错误，不可以改变p的指向
所以一个指针，的const有两层含义，一个是可不可以改变指针的值，一个是可不可以通过指针改变所指向的值。只有下面的声明才是真正的const字符串：const char str[] = &hello&;
四、volatile
这部分参考：
这个关键字告诉编译器，不要优化～
volatile int i=10;
volatile 告诉编译器i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的可执行码会重新从i的地址读取数据放在k中。 而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在k中。而不是重新从i里面读。这样以来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问，不会出错。
下面是volatile变量的几个例子：
1) 并行设备的硬件寄存器（如：状态寄存器）
2) 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
3) 多线程应用中被几个任务共享的变量
还有几个问题：
1)一个参数既可以是const还可以是volatile吗？解释为什么。
2) 一个指针可以是volatile 吗？解释为什么。
3) 下面的函数有什么错误：
int square(volatile int *ptr)
return *ptr * *
下面是答案：
1)是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变（不大懂，这里貌似不是程序修改，是操作系统更改的）。它是const因为程序不应该试图去修改它。
2)是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
3) 这段代码有点变态。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：
int square(volatile int *ptr)
return a *
由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：
long square(volatile int *ptr)
return a *
“告诉compiler不能做任何优化”其实有常见的两点：
一、赋值优化的时候
&& 比如要往某一地址送两指令：
&& int *ip =...; //设备地址
&& *ip = 1; //第一个指令
&& *ip = 2; //第二个指令
&& 以上程序compiler可能做优化而成：
&& int *ip = ...;
&& *ip = 2;
&& 结果第一个指令丢失。如果用volatile, compiler就不允许做任何的优化，从而保证程序的原意：
&& volatile int *ip = ...;
&& *ip = 1;
&& *ip = 2;
&& 即使你要compiler做优化，它也不会把两次付值语句间化为一。它只能做其它的优化。这对device driver程序员很有用。
二、表示用volatile定义的变量会在程序外被改变,每次都必须从内存中读取，而不能把他放在cache或寄存器中重复使用。
&&&&&&& a=0;
&&&&&& while(!a){
&&&&&& }&&
&&&&&& doother();
&& 如果没有 volatile doother()不会被执行
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：340221次
积分：5258
积分：5258
排名：第4127名
原创：207篇
转载：36篇
评论：47条
(2)(3)(1)(2)(2)(1)(1)(4)(5)(4)(1)(35)(1)(2)(1)(3)(3)(1)(1)(7)(3)(3)(4)(1)(2)(9)(1)(2)(4)(6)(4)(13)(8)(6)(15)(14)(12)(24)(13)(16)(5)定义：用static关键字声明的数据成员称为静态数据成员。
每个类只有一个存储单元，静态数据成员为该类的所有对象共有，不属于某个对象。静态数据成员的初始化必须在类以外进行定义性说明。
形式为：类型类名：：静态数据成员值
静态成员注意以下几点：
、静态成员必须初始化，如果其是有公共访问属性的可以通过对象重新设置值，其最终值以最后一次设置的为准。
、初始化方式只能是在类以外进行定义性说明
、访问方式可以是对象静态成员或：：静态数据成员
通过下面的例子来理解定义：
&//静态数据成员的定义形式
//必须在类外声明性初始化，其他任何初始化都是错误的。
c.area = 8;//初始化后可以改变其值，不初始化程序编译都通不过
f.area =16;
都输出。以最后一次的改变为准所有对象共享统一静态成员内存空间，两种访问方式都行，当然必须是公共的静态成员，私有的不能在类外访问。
2.静态数据成员被 类 的所有对象所共享，包括该类派生类的对象。即派生类对象与基类对象共享基类的静态数据成员。举例如下：
class base{
static int _//声明
int base::_num=0;//静态数据成员的真正定义
class derived:public base{
a._num++;
cout&&&base class static data number _num is&&&a._num&&
b._num++;
cout&&&derived class static data number _num is&&&b._num&&
// 结果为1,2;可见派生类与基类共用一个静态数据成员。
3.静态数据成员可以成为成员函数的可选参数，而普通数据成员则不可以。举例如下：
class base{
static int _staticV
void foo1(int i=_staticVar);//正确,_staticVar为静态数据成员
void foo2(int i=_var);//错误,_var为普通数据成员
4.★静态数据成员的类型可以是所属类的类型，而普通数据成员则不可以。普通数据成员的只能声明为 所属类类型的 指针或引用。举例如下：
class base{
static base _object1;//正确，静态数据成员
base _object2;//错误
base *pO//正确，指针
base &mO//正确，引用
5.★这个特性，我不知道是属于标准c++中的特性，还是vc6自己的特性。
静态数据成员的值在const成员函数中可以被合法的改变。举例如下：
class base{
base(){_i=0;_val=0;}
mutable int _i;
static int _staticV
void test() const{//const 成员函数
_i++;//正确，mutable数据成员
_staticVal++;//正确，static数据成员
_val++;//错误
int base::_staticVal=0;
定义：用static关键字声明的函数成员称为静态函数成员。
每个类只有一个存储单元，静态函数成员为该类的所有对象共有，不属于某个对象。共有的静态函数成员可以通过类名或对象名来调用。静态函数成员必须通过对象名来访问非静态数据成员。静态成员呢？
静态成员函数在类外实现时候无须加关键字，否则是错误的。
通过下面题目来理解静态成员函数
：静态函数成员必须通过对象名来访问非静态数据成员。找出下面程序的错误。
static int getVal()
错误不能调用非静态数据成员，要通过类的对象来调用。
通过类的对象来引用非静态数据成员改正如下：
static int getVal(A a);//静态成员函数
在类外实现静态成员函数，不能加关键字。
、静态函数成员可以调用静态数据成员
static int getVal(A a);
static int staticV
正确的调用方法一
正确的调用方法二
正确的调用方法三
1.静态成员函数的地址可用普通函数指针储存，而普通成员函数地址需要用 类成员函数指针来储存。举例如下：
class base{
static int func1();
int func2();
int (*pf1)()=&base::func1;//普通的函数指针
int (base::*pf2)()=&base::func2;//成员函数指针
2.静态成员函数不可以调用类的非静态成员。因为静态成员函数不含this指针。
3.静态成员函数不可以同时声明为 virtual、const、volatile函数。举例如下：
class base{
virtual static void func1();//错误
static void func2()//错误
static void func3()//错误
最后要说的一点是，静态成员是可以独立访问的，也就是说，无须创建任何对象实例就可以访问。
全局变量与全局静态变量的区别：
(a）若程序由一个源文件构成时，全局变量与全局静态变量没有区别。
(b)若程序由多个源文件构成时，全局变量与全局静态变量不同：全局静态变量使得该变量成为定义该变量的源文件所独享，即：全局静态变量对组成该程序的其它源文件是无效的。
(c)具有外部链接的静态；可以在所有源文件里调用；除了本文件，其他文件可以通过extern的方式引用；
静态全局变量的作用：
（a）不必担心其它源文件使用相同变量名，彼此相互独立。
（b）在某源文件中定义的静态全局变量不能被其他源文件使用或修改。
(c) 只能在本文件中使用！具有内部链接的静态；不允许在其他文件里调用；
数据成员可以分静态变量、非静态变量两种
静态成员：静态类中的成员加入修饰符即是静态成员可以直接使用类名静态成员名访问此静态成员因为静态成员存在于内存非静态成员需要实例化才会分配内存所以静态成员不能访问非静态的成员因为静态成员存在于内存所以非静态成员可以直接访问类中静态的成员
非成静态员：所有没有加的成员都是非静态成员当类被实例化之后可以通过实例化的类名进行访问非静态成员的生存期决定于该类的生存期而静态成员则不存在生存期的概念因为静态成员始终驻留在内容中
一个类中也可以包含静态成员和非静态成员类中也包括静态构造函数和非静态构造函数
分两个方面来总结，第一方面主要是相对于面向过程而言，即在这方面不涉及到类，第二方面相对于面向对象而言，主要说明在类中的作用。
一、在面向过程设计中的关键字
、静态全局变量
定义：在全局变量前，加上关键字该变量就被定义成为了一个静态全局变量。
、该变量在全局数据区分配内存。
、初始化：如果不显式初始化，那么将被隐式初始化为自动变量是随机的除非显式地初始化。
、访变量只在本源文件可见，严格的讲应该为定义之处开始到本文件结束。
、文件作用域下声明的的常量默认为存储类型。
静态全局变量不能被其它文件所用；好像是区别的
其它文件中可以定义相同名字的变量，不会发生冲突；
全局变量与全局静态变量的区别：(a）若程序由一个源文件构成时，全局变量与全局静态变量没有区别。(b)若程序由多个源文件构成时，全局变量与全局静态变量不同：全局静态变量使得该变量成为定义该变量的源文件所独享，即：全局静态变量对组成该程序的其它源文件是无效的。(c)具有外部链接的静态；可以在所有源文件里调用；除了本文件，其他文件可以通过的方式引用；
静态全局变量的作用：（）不必担心其它源文件使用相同变量名，彼此相互独立。
（）在某源文件中定义的静态全局变量不能被其他源文件使用或修改。
只能在本文件中使用！具有内部链接的静态；不允许在其他文件里调用；
通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体，系统就会收回栈内存，局部变量也相应失效。
但有时候我们需要在两次调用之间对变量的值进行保存。通常的想法是定义一个全局变量来实现。但这样一来，变量已经不再属于函数本身了，不再仅受函数的控制，给程序的维护带来不便。
静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值。
、该变量在全局数据区分配内存。
、初始化：如果不显式初始化，那么将被隐式初始化为以后的函数调用不再进行初始化。
、它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或　语句块结束时，其作用域随之结束。、静态函数（注意与类的静态成员函数区别）定义：在函数的返回类型前加上关键字，函数即被定义成静态函数。特点：
、静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。
定义静态函数的好处：静态函数不能被其它文件所用；
其它文件中可以定义相同名字的函数，不会发生冲突；
二、面向对象的关键字（类中的关键字）
、静态数据成员
在类内数据成员的声明前加上关键字，该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。
声明静态数据成员
定义并初始化静态数据成员
可以看出，静态数据成员有以下特点：
对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；
静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。在中，语句是定义静态数据成员；
静态数据成员和普通数据成员一样遵从访问规则；
因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它；
静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为：
＜数据类型＞＜类名＞＜静态数据成员名＞＜值＞
类的静态数据成员有两种访问形式：
＜类对象名＞＜静态数据成员名＞或＜类类型名＞＜静态数据成员名＞
如果静态数据成员的访问权限允许的话（即的成员），可在程序中，按上述格式来引用静态数据成员；
静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类，每个实例的利息都是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了；
同全局变量相比，使用静态数据成员有两个优势：
静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；
可以实现信息隐藏。静态数据成员可以是成员，而全局变量不能；
、静态成员函数
与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个指针，指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，是缺省的。如函数实际上是。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。下面举个静态成员函数的例子。
声明静态成员函数
声明静态数据成员
定义并初始化静态数据成员
非静态成员函数可以访问静态数据成员
静态成员函数的实现
错误代码，是非静态数据成员
关于静态成员函数，可以总结为以下几点：
出现在类体外的函数定义不能指定关键字；
静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；
非静态成员函数可以任意地访问静态成员函数和静态数据成员；
静态成员函数不能访问非静态成员函数和非静态数据成员；
由于没有指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；
调用静态成员函数，可以用成员访问操作符和为一个类的对象或指向类对象的指针调用静态成员函数，
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：51747次
排名：千里之外
转载：148篇
(10)(1)(2)(3)(1)(1)(2)(2)(9)(3)(4)(20)(31)(21)(4)(1)(16)(7)(14)JAVA 里static 和volatile的区别_新浪浙江教育_新浪浙江
JAVA 里static 和volatile的区别
来源：新浪浙江教育日15:11字号：|
　　变量放在主存区上，使用该变量的每个线程，都将从主存区拷贝一份到自己的工作区上进行操作。
　　volatile, 声明这个字段易变(可能被多个线程使用)，Java内存模型负责各个线程的工作区与主存区的该字段的值保持同步，即一致性。
　　static, 声明这个字段是静态的(可能被多个实例共享)，在主存区上该类的所有实例的该字段为同一个变量，即唯一性。
　　volatile, 声明变量值的一致性；static,声明变量的唯一性。
　　此外，volatile同步机制不同于synchronized, 前者是内存同步，后者不仅包含内存同步(一致性)，且保证线程互斥(互斥性)。
　　static 只是声明变量在主存上的唯一性，不能保证工作区与主存区变量值的一致性；除非变量的值是不可变的，即再加上final的修饰符，否则static声明的变量，不是线程安全的。
　　下面摘自Java语言规范(Java Language Specification)的官方解释：
　　1) If a field is declared static, there exists exactly one incarnation of the field, no matter how many instances (possibly zero) of the class may eventually be created.&
　　A field may be declared volatile, in which case the Java Memory Model ensures that all threads see a consistent value for the variable。
总编：毛亚明
邮箱：yaming@.cn
策划：罗夏兰
邮箱：xialan@.cn