Static:静态存储，内部链接。
１．函数内部的静态变量内部类型：在定义的时候初始化，如果未初始化，编译器将其设置为０．
自定义类型：在定义的时候调用构造函数，如未传递参数，调用默认构造函数。包含局部对象的函数如果未被调用，则该局部对象不会构造，也不会析构。
void f()
{
static Obj b('b');
}
void g()
{
Obj c('c');
}
int main()
{
return 0;
}// no constructor both c and b
内部链接的好处是，可以将这个名字放在头文件中而不用担心链接时发生冲突。（链接时发现多个同一名字的定义会报错，不知道该链接哪一个了）。通常将变量、内联函数放在头文件中，因为这些默认是内联的。
链接只引用那些在链接／装载期间有地址的成员，因此类声明和局部变量并不链接。
２．全局变量：
static int a = 0;//definition, internal linkage, static storage area
extern int b = 0;//definition,external linkage, static storage area
３。局部变量：static只改变变量的存储类型。而extern只是用作声明，表示某处已经存在一个存储区。
４。函数名：只改变可见性，static 仅该翻译单元可见，extern（默认）外部可见。
名字空间解决冲突
1)只能在全局范围内定义，可以相互嵌套
2)定义结尾处不需要有分号
3)可以在多个头文件中用一个标识符
4)可以用另一个名字空间做别名
namespace longName
{
int i = 0;
}
namespace LN = longName;
5)不能创建实例
每个翻译单元只能有一个未命名的名字空间，默认为内部链接。
namespace{
class A{};
class B{};
int i, j , k;
}
可以在一个名字空间的类定义之内插入一个友元声明，该友元自动成为该名字空间的一员。
namespace Me
{
class Us{
friend void you();// you is member of namespace Me
};
}
使用名字空间
using 声明
namespace U
{
inline void f(){}
inline void g(){}
}
namespae V
{
inline void f(){}
inline void g(){}
inline void g(int){}
inline char g(char){return 'a';}
}
void h()
{
using namespace U;
using V::g;//没有类型方面的信息，声明了这个空间中的所有重载函数
g();
g(1);
g('b');
U::g();
}
不要在头文件中使用using namespace ...会污染所有包含该头文件的编译单元。
C++中的静态成员
所有的类公用一块内存区域，可以进行类内部通信。如果一个静态数据成员被声明但是未被定义，连接器会报一个错误。
定义必须出现在类的外部，且只能定义一次，通常放在类的实现文件中。
//.h file
class A
{
static int i ;
public:
//
};
//.cpp file
int A::i = 1;
这些都是类创建者应该做的，所以，客户程序员不需要再定义一次了。
静态数组的初始化
在类外初始化
class Value{
static const int scSize = 100;//非常特殊，内部类型可以这样定义，也可以在类外定义。
static const float scFloat;
static const int scInts[];
};
const int Value::scFloat = 1.0f;
const int Value::scInts[]={2,23,4};
自定义类型： 必须在类外初始化
class Stat
{
static X x1;
static X xTable[];
static const X x2;
static const X xTable2[];
};
X Stat::x1(100);
X Stat::xTable[] = { X(1), X(2), X(3)};
const X Stat::x2(200);
const X Stat::xTable2 = {X(2), X(4), X(10) };
局部类中不能有static 数据成员。
静态成员函数:没有隐含的this指针，所以不能调用非静态成员函数。
静态初始化的相依性：一个对象的初始化必须需要另一个对象先初始化，如果初始化顺序不对，则造成错误。解决方法：利用函数
１．头文件中声明一个函数，且不能为内联。
２．实现文件中定义一个静态对象，并返回引用。
//Dependency1StatFunc.h
#include "Dependency1.h"
extern Dependency1& d1();
//Dependency2StatFunc.h
#include "Dependency2.h"
extern Dependency2& d2();
//Dependency1StatFunc.cpp
#include "Denpendency1StatFunc.h"
Dependency1& d1()
{
static Deppendency1 dep1;
return dep1;
}
//Dependency2StatFunc.cpp 静态对象一般放在单独的文件中定义，但要在头文件中声明。
#include "Denpendency1StatFunc.h"
#include "Denpendency2StatFunc.h"
Dependency2& d2()
{
static Deppendency2 dep2(d1());//调用d1()的时候dep1已经初始化了
return dep2;
}
使用ｃ类型的函数
extern "c" float f(int a);
extern "c"{
#include "Myheader.h"
}
extern "c"
{
float f();
double d();
}
posted on 2012-05-31 14:30
Dino-Tech 阅读(135)
评论(0) 编辑 收藏 引用