C++几个关键字总结——const、static、extern、volatile（一）

原文链接：https://blog.csdn.net/qq_34805255/article/details/88413156

1.const的用法

const 基本原理 ： 被修饰的对象的值不可以被修改
const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。

（1）const修饰基本数据类型

表示常量，必须进行初始化，有以下两种初始化的方式：
编译时初始化： 编译器在编译时会把所有用到j的地方都替换成对应常数，如const int a=42;，即这种情况下，编译器是不为常量a分配内存的

运行时初始化：初始值不是常量表达式， 如const int i=get_size();

（2）const修饰引用

表示对常量的引用，不能通过此引用修改它所指向的对象，只是限制了这个操作，并未限制它指向的对象（可以是非const的）。

（3）const修饰指针

int a = 0;
int *const b=a;     //b是指向非常量int的常量指针，指针本身不可变，即该指针的指向（存储的地址）不可变，但可以通过它修改它所指向的对象
 
const int c = 0;
const int *d = c;  //c是指向const int的非常量指针，也就是该指针所指的对象不可变，即不能通过指针去修改它所指向的对象
                   //但可以修改它自己的存放的地址（指向）
 
 
const int* const e = c;   //e是指向const int的常量指针，指针的指向和指针所指的对象都不可变

对于指向常量的非常量指针，也只是限制了通过此指针去修改该它所指的对象这样的操作，并未限制它所指象的对象（可以是非const的）

（4）const修饰常对象

常对象是指对象常量，定义格式如下：
class A; const A a;
A const a;

定义常对象时，同样要进行初始化，并且该对象不能再被更新，修饰符const可以放在类名后面，也可以放在类名前面。

const对象只能访问const成员函数，而非const对象可以访问任意的成员函数，包括const成员函数；

（5）const修饰函数形参

传递过来的参数在函数内不可以改变

（6）const修饰函数返回值

待补充

（7）const修饰成员函数

放在函数声明的最后面即形参列表的括号后面，如下：

class ClassName { 
public:     
int Fun() const;   
}；

表示该函数不可以修改该类的成员变量的值，并且不可以调用类中非成员函数，但非const成员函数可以调用const成员函数；

（8）在多个文件共同使用一个const常量

待补充

2.static的用法

主要有2种用法：

<1>限定作用域，比如

修饰全局变量-全局静态变量
在全局变量前加上关键字static，全局变量就定义成一个全局静态变量（限定作用域）。全局静态变量作用域被限定，只在定义它的文件之内可见，准确地说是从定义之处开始，到文件结尾。
test.c

#include <stdio.h>
 
static int s_a = 20; // 如果不想该变量被其它文件访问，则需要加上static
 
int get_a(void)
{
	return s_a;
}

main.c

#include <stdio.h>
 
extern int s_a;   
extern int get_a(void);
int main()
{
	//printf("s_a = %d\n", s_a);   无法打印s_a，因为它是static的
	printf("s_a = %d\n", get_a()); //我们可以使用函数接口来访问s_a
	return 0;
}

修饰函数-静态函数
在函数返回类型前加关键字static，函数就定义成静态函数。静态函数只是在定义他的文件当中可见，不能被其他文件所用。
test.c

#include<stdio.h>
 
 
static void printf_static_func()
{
    printf("printf_static_func() be called\n");
}
 
void test()    //要在其他文件使用只能再加一层函数调用
{
    printf_static_func();
}

test2.c

#include<stdio.h>
 
 
static void printf_static_func()
{
    printf("printf_static_func() be called\n");
}
 
static void test()    //在其他文件中不可见，加了static,不会引起重定义错误
{
    printf_static_func();
}

main.c

#include <stdio.h>
 
extern void test();
int main()
{
	test();
	return 0;
}

使用原则：
（1）某一个函数不想被其他模块所引用，则使用static进行修饰；

（2）不同的文件可能函数命名有相同，此时使用static进行修饰可以解决重名的问题。

修饰成员变量
一个类的成员为 static 时，即为静态成员，从属于于类，这个类无论有多少个对象被创建，这些对象共享这个 static 成员，静态数据成员一旦被定义一直存在于程序的整个生命周期中

静态成员变量初始化：：不是由类的构造函数初始化，一般不能在类的内部初始化静态成员变量，只是在类的内部声明，在类的外部定义和初始化，格式如下：

格式：数据类型 类名:: 静态数据成员名 = 值
访问静态成员变量格式：类名>::静态成员名

如果创建了对象，也可以用对象来访问：
对象名.静态成员名
对象指针->静态成员名

静态数据成员与普通数据成员的区别：
（1）静态数据成员的类型可以是它所属的类类型，而非静态数据成员，只能声明成它所属类的指针或引用
（2）可以使用静态成员变量作为默认实参，而普通成员变量不可以，因为它的值属于对象的一部分，这么做无法真正提供一个对象以便从中获取成员的值
（3）静态成员变量使用前必须进行初始化，而普通成员变量如果不初始化，会被默认初始化
（4）对于类中的static成员变量只有在静态区中的一块内存，在编译时确定，不随对象开辟新的空间；而普通成员会随对象开辟新的空间

修饰成员函数
静态成员函数没有this指针，不能声明成const，不能在static函数体内使用this指针。成员函数不用通过作用域运算符就能直接使用静态成员。

可以在类的内部定义静态函数，也可以在类的外部，但static关键字只能出现在类内部的声明语句中，只出现一次

在类外调用静态成员函数用 “类名 :: ”作限定词，或通过对象调用

静态成员函数不能调用非静态成员函数或变量，但非静态成员函数可以调用静态成员函数或变量，因为静态成员从属于类，非静态成员从属于对象，静态成员在编译时就确定，而这时对象还没有被创建，所以对非静态成员并没有确定的对象来访问，而在调用对象的非静态成员函数时，静态成员已经确定，所以能正确调用。

静态成员函数的应用：单例模式

//定义一个指向当前类对象的static指针变量
//定义获取单例的接口函数
#include <stdlib.h>
#include <iostream>
 
using namespace std;
 
class  demo {
public:
	demo() {}
 
	~demo() {
		cout << "~析构" << endl;
	}
 
	/*单例模式*/
	static demo * getInstance() {
		if (single == NULL) {
			single = new demo();
		}
 
		return single;
	}
 
	//静态成员函数
	static void set_b(int _b) {
		b = _b;
	}
 
	static int get_b() {
		return b;
	}
 
public:
	int a;
 
private:
	static  int b;
	static  demo * single; //指向类的静态指针
 
	//static demo single;  虽然我们这样定义数据成员，但是在C++中没有空对象的概念，
	                    // 所以一般使用指针，来判断是否为空
};
 
int demo::b = 10;
demo * demo::single = NULL;
 
void test() {
	demo *d2 = demo::getInstance();
	cout << "d2->get_b()的值是：" << d2->get_b() << endl;
	cout << "d2->a 的值是：" << d2->a << endl;
	printf("d2 的指针是： %p\n", d2);
	d2->set_b(8888);
	d2->a = 8888;
}
 
int main(void) {
 
	//demo::b = 100;
	//没创建对象前，如何修改私有static 成员变量的值
	//使用static函数
	demo::set_b(100);
 
	demo demo1;
	demo1.set_b(1000);
	cout << "demo.get_b()的值是：" << demo::get_b() << endl;
 
	//测试单例模式
	demo * d1 = demo::getInstance();
	d1->set_b(6666);
	d1->a = 6666;
	cout << "d1->get_b()的值是：" << d1->get_b() << endl;
	cout << "d1->a 的值是：" << d1->a << endl;
	printf("d1 的指针是： %p\n", d1);
 
	test();
	cout << "after test(), d1->get_b()的值是：" << d1->get_b() << endl;
	cout << "after test(), d1->a 的值是：" << d1->a << endl;
 
	return 0;
}

<2>保持变量内容持久化；

修饰局部变量-局部静态变量
在局部变量之前加上关键字static，局部变量就成为一个局部静态变量。

作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域结束。局部静态变量和普通局部变量的作用域是一模一样的，即都只能在定义它的函数或语句块中使用，在不同的作用域中的同名static变量的内存地址也不一样

生命周期：但是当局部静态变量离开作用域后，并没有销毁，而是仍然驻留在内存当中，该函数再次被调用，其值和前次调用退出时一样。

局部变量是定义在栈上，函数退出后变量就被销毁。局部静态变量是定义在静态区，其在程序开始运行时就已经在内存里面。在整个程序结束时才会被销毁