（1）在c当中的作用#

隐藏（对变量和函数）

在C语言中，static修饰的函数和变量具有只对本文件可见的作用，因此它具有对其他源文件隐藏的功能，利用这一特性可以在不同源文件定义同名函数和同名变量，从而不会引起命名冲突。

保持变量持久，默认初始值为0（对变量）

也就是说，用static修饰的变量，生命周期是全局的，会一直存在到程序运行结束，但它的定义域还是跟普通变量一样。用static修饰的变量会存储在静态存储区，这里的变量会在程序刚开始运行的时候就进行初始化，也是唯一的一次初始化。同时静态存储区的字节默认初始值都为0x00，全局变量也存储在这里。

（2）在c++当中的作用#

当然static在C中的作用在C++中同样适用。

类的静态成员函数是属于整个类的而非某个对象,并且它没有this指针。由此引申出,它不能访问非静态数据和非静态成员函数,以及不能被声明为virtual、const、volatile。这几点需要对C++的内存模型有一定的理解才能明白。

类的静态数据成员同样是属于类的,对象都可以进行访问。初始化需要在类外进行。初始化格式：<数据类型><类名>::<静态数据成员名>=<值>。

一个注意点：只有静态常量整型变量才可以在类里面初始化，其他都不行。

在C++中，static静态成员变量不能在类的内部初始化。在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化，如：double Account::Rate = 2.25;static关键字只能用于类定义体内部的声明中，定义时不能标示为static

在C++中，const成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数。

const数据成员 只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类的声明中初始化const数据成员，因为类的对象没被创建时，编译器不知道const数据成员的值是什么。

const数据成员的初始化只能在类的构造函数的初始化列表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现，或者static cosnt。

（1）C中的NULL#

在C语言中我们将NULL用作空指针之用，NULL在C语言中的定义如下：

#define NULL ((void *)0)

可以看到，C语言中NULL是一个void*指针，我们常用其来对指针变量进行初始化赋值或者作为返回类型为指针的函数的返回值（如函数执行失败时）等等。

（2）C++中的NULL#

在C++中，NULL的定义如下：

1
`/* Define NULL pointer value */
2
#ifndef NULL
3
    #ifdef __cplusplus
4
        #define NULL    0
5
    #else  /* __cplusplus */
6
        #define NULL    ((void *)0)
7
    #endif  /* __cplusplus */
8
#endif  /* NULL */

可以看到，在C++中，NULL被定义为0，而不是(void*)0，为什么C++在NULL的定义上不继续兼容C延续(void*)0的定义呢？因为C++中不能将void类型的指针隐式转换成其他指针类型，所以将NULL定义为(void)0的话并不能起到空指针的作用，如以下代码：

1
void hello(char* a) {
2
    printf("char\n");
3
}
4

5
int main() {
6
    void* a = (void*) 0;
7
    char* b = a;     //在C中可以，C++不行
8
    hello(b);        //在C中可以，C++不行
9
    return 0;
10
}

因为C++中不能将void类型的指针隐式转换成其他指针类型，所以用(void**)0对其他类型指针赋初值是不行的。既然(void)0不能起到空指针的作用，不如干脆将NULL定义为0，引入0来表示空指针，可以对各种类型的指针进行赋值。

（3）C++中的nullptr#

用过C++的童鞋都知道C++中有个nullptr的关键字可以用作空指针，既然已经有了定义为0的NULL，为何还要nullptr呢？这是因为定义为0的NULL很容易引起混淆，尤其是函数重载调用时，比如说：

1
void hello(char* a) {
2
    printf("char\n");
3
}
4
void hello(int a) {
5
    printf("int\n");
6
}
7

8
int main() {
9
    hello（NULL）;    //调用hello(int a)函数
10
    return 0;
11
}
12
如果在C++中还是用NULL来用作空指针的话，我们会以为hello(NULL)调用的是hello(char* a)，但实际上，因为NULL定义为0，所以调用的是hello(int a)。所以为了避免这种混淆，C++定义了nullptr关键字用作空指针。

1
char *p1 = nullptr;     // 正确
2
int  *p2 = nullptr;     // 正确
3
bool b = nullptr;       // 正确. if(b)判断为false
4
int a = nullptr;        // 错误

（1）任何类型的指针都可以直接赋值给void指针， 且无需进行强制类型转换。#

任何类型指针都可以直接赋值给void指针。

1
double obj = 3.14, *pd = &obj;
2
void* pv = &obj;        // 正确，void* 能存放任意类型对象的地址
3
                        // obj 可以是任意类型的对象
4
pv = pd;
5

6
             // 正确，pv 可以存放任意类型的指针

（2）void指针并不能无需类型转换直接赋值给其他类型，如果要把 void 类型的指针赋值给其他类型的指针，需要进行显式转换。#

（2）void指针并不能无需类型转换直接赋值给其他类型 如果要把 void 类型的指针赋值给其他类型的指针，需要进行显式转换。

1
double obj = 3.14, *pd = &obj;
2
void *pv = &obj;
3

4
double *pd1 = pv;               // 错误，不可以直接赋值
5
double *pd2 = (double*)pv;      // 必须进行显示类型转换
6
cout  func1(); ×
7
aObj-> func2(); 正确

三、将Const类型转化为非Const类型的方法#

采用const_cast 进行转换。 用法：const_cast (expression) 该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。

• 常量指针被转化成非常量指针，并且仍然指向原来的对象；

• 常量引用被转换成非常量引用，并且仍然指向原来的对象；

• 常量对象被转换成非常量对象。

1
class A
2
{
3
  public: A() {}
4

5
  private: static const int i;//注意必须是静态的！
6
}；
7

8
  const int A::i=3;

1
class A
2
{
3
 public: A(int i=0):test(i) {}
4
 private: const int i;
5
}；