资料：https://www.runoob.com/w3cnote/cpp-keyword-intro.html
一、基本关键字（14个）
最基础的关键字，没什么可说的
1、变量类型（6个）
int、char、double、float、void
2、流程（9个）
if、else、while、for、break、continnue、switch、case、return
二、简单关键字（25个）
复杂一点，但有必要会、而且好理解的关键字
1、变量类型、指针、引用、数组大小
（1）auto
在给变量赋值时可以用来省略前面的类型，变量的类型由后面的赋值确定。使用的时候必须赋值，不能先声明后定义。
#include <iostream>
int main(){
int i = 0;
auto j = i;
std::cout << "out:" << j <<std::endl;
return 0;
}
（2）*
定义指针和取值
- 一个变量分为变量名、存储数值和存储地址三部分。指针变量也是变量，但存储数值是另一个变量的地址。指针变量就是专门用来存储地址的变量，因为地址不是那些常见的变量类型，比如int、double等。
- 星号作为指针使用的时候需要和前面的数据结构一起出现，比如int* 、char*等，代表指向变量的类型，如整型指针。
- 星号作为取值使用的时候代表指针变量的值所对应的地址上的存储数值。
#include <iostream>
int main(){
int i =0;
int* j; //定义整型指针变量
j = &i; //变量（指针指向的地址）是i的地址
std::cout << "out:" << *j <<std::endl; //对j取值
return 0;
}
out:0
（3）&
引用和取地址
- 引用的使用方法比较固定，基本都是像下面那个例子那样，唯一有变化的就是作为函数形参的时候。引用的作用是使得两个变量公用地址和数值，也就是给原变量取了一个别名。
- 取值就是在后变量在一起的时候，代表变量的地址。
#include <iostream>
int main(){
int i =0;
int& j = i;
std::cout << "value:" << i << " and " << j <<std::endl;
std::cout << "path:" << &i << " and " << &j <<std::endl;
std::cout << "_____change value_____" <<std::endl;
j = 1;
std::cout << "value:" << i << " and " << j <<std::endl;
std::cout << "path:" << &i << " and " << &j <<std::endl;
return 0;
}
value:0 and 0
path:0x61fe14 and 0x61fe14
_____change value_____
value:1 and 1
path:0x61fe14 and 0x61fe14
- 总结一下*和&
以变量A为例，变量名是A同时A也代表A的数值，&A代表A的地址。
& + 变量 = 地址 ； * + 地址 = 变量；
（4）sizeof
输出变量的长度，一直以为是个函数，但其实是关键字
#include <iostream>
int main(){
short int i = 0;
long int j =0;
int l1 = sizeof(i);
int l2 = sizeof(j);
std::cout << "value:" << l1 <<std::endl;
std::cout << "value:" << l2 <<std::endl;
return 0;
}
value:2
value:4
2、流程
流程的都比较简单，这几个用到少一点，写一下示例。
（1） goto
#include <iostream>
int main(){
int i = 0;
while( i<10 ){
std::cout << "value:" << i <<std::endl;
goto position;
}
position: std::cout << "goto:" << i <<std::endl;
return 0;
}
value:0
goto:0
（2）do和while
进行判断之前会先走一次函数内部的程序。
#include <iostream>
int main(){
int i = 0;
do
{
i++;
std::cout << "value:" << i <<std::endl;
}while( i>10 );
return 0;
}
（3）switch和default
#include <iostream>
int main(){
int i = 10;
switch (i) {
default:
std::cout << "default" <<std::endl;
case 0:
std::cout << "0" <<std::endl;
break;
case 1:
std::cout << "1" <<std::endl;
break;
}
return 0;
}
default
0
1、前缀修饰
变量前缀
（1） signed和unsigned、long和short
修改存储数值的方式和范围
signed、unsigned：是否有符号，默认为有符号
long、short：变量占的字节多少，默认为长型
（2）const和volatile
这两个都是对编译器在编译时候的操作做出了特定的规定。
const（不变的）
- 常量，应用于定义不会改变的量的场景。编译器遇到这中变量的时候往往会直接用数值替代，所以下面这个变量在输出的时候仍然是最开始定义的值。
- 使用const的变量默认是没有外部连接性的，即使是全局变量也没有。
#include <iostream>
int main(){
const int a = 6;
int* p = (int*)&a;
*p = 12;
std::cout << "value:" << a <<std::endl;
return 0;
}
const比较常见的操作是作为函数的形参，const &被称作万能引用，常被用于引用不会变化的函数形参。一般来说，不变参数用const &，变得参数用指针。
volatile（易变的）
这个关键字是告诉编译器在处理这个变量的时候，每次都要从对应的地址重新获得数值。下面这段代码从结果看不出什么，但是对编译器来说，有可能进行优化在第二次赋值的时候直接附上上一次i的值。
#include <iostream>
int main(){
volatile int i = 10;
int a = i;
int b = i;
std::cout << "value:" << b <<std::endl;
return 0;
}
（3）static和extern
资料：https://blog.csdn.net/wangjie36/article/details/126314729
全局和局部变量
- 在函数中定义的变量是局部变量，其作用于函数内部，没有外部链接性。在函数外部定义的变量是全局变量，可以作用于整个工程，有外部链接性。函数的作用域默认是整个工程。当工程中的其他文件想调用其他文件的变量或函数的时候，可以使用extern进行声明，告诉编译器这里的变量或函数是使用的外部变量或函数。局部变量没有外部链接性，所以无法被extern调用。反之，如果想让函数或全局变量无法被其他文件调用，只在本文件中发生作用就要使用static，这样即使其他文件使用extern，也无法调用对应变量或函数。static还有一个特殊用法，在对局部变量使用时可以使其直到程序结束才被释放。
- 是否有外部链接性说明是否有能力被其他文件获得，而extern则是打开连接的开关。
static（静态的）
- 对于局部函数，静态变量会存储在静态变量区，直到程序结束才会释放（原本局部函数存储在栈中，在函数结束时释放），跟普通局部变量一样只能在函数内部使用。
- 对于全局变量和函数，会限制其作用区域，都只能在本源文件中使用。
lib.h
#ifndef __LIB_H__
#define __LIB_H__
#include <iostream>
void func();
#endif
lib.cpp
#include "lib.h"
using namespace std;
static int number =10;
void func()
{
cout << "value:" << number <<endl;
}
main.h
// #include "lib.h"
extern void func();
main.cpp
#include "main.h"
int number = 20;
int main()
{
func();
return 0;
}
输出
value:10
extern（外部的）
被用于声明变量或函数，告诉编译器这是一个在外部定义的变量或函数。如果想引入外部变量或函数，其实也可以直接include对应头文件，但是这样可能会增加无关的外部变量和函数。
调用其他文件的函数和变量
lib.h
#ifndef __LIB_H__
#define __LIB_H__
#include <iostream>
void func();
int number;
#endif
lib.c
#include "lib.h"
using namespace std;
void func(int i)
{
cout << "value:" << i <<endl;
}
main.h
// #include "lib.h"
extern void func(int i);
extern int number;
main.cpp
#include "main.h"
int main()
{
number = 2;
func(number);
return 0;
}
输出
value:10
在lib.h中声明的函数和变量的作用域都是整个项目，通过main.h用extern引入，main中可以直接使用。这里一旦去掉main.h中对lib头文件的引入，则会产生重复报错。
2、数据结构
（1）strcut（结构体）
struct 结构体名{
结构体所包含的变量;
}; //定义结构体类型
结构体名 结构体变量； //定义结构体变量
（2）union（联合体）
联合体内部的变量都拥有同一个地址，也就是这些变量中只有一个可以被赋值
#include <iostream>
union test_union{
char mark;
long num;
float score;
};
test_union test;
int main()
{
std::cout << sizeof(test) << std::endl;
test.mark = 'q';
std::cout << "mark:" << test.mark << std::endl;
test.score = 1.0;
std::cout << "score:" << test.score << std::endl;
std::cout << "mark:" << test.mark << std::endl;
return 0;
}
4
mark:q
score:1
mark:
（3）enum（枚举）
枚举中第一个变量默认为0，后续逐步加1，也可以指定特定变量的值。
#include <iostream>
enum number_enum {n1, n2, n3=3, n4, n5, n6, n7};
number_enum number;
int main()
{
std::cout << "n1:" << n1 << std::endl;
std::cout << "n2:" << n2 << std::endl;
std::cout << "n3:" << n3 << std::endl;
std::cout << "n4:" << n4 << std::endl;
std::cout << "n5:" << n5 << std::endl;
std::cout << "n6:" << n6 << std::endl;
std::cout << "n7:" << n7 << std::endl;
return 0;
}
n1:0
n2:1
n3:3
n4:4
n5:5
n6:6
n7:7
（4）typedef（类型定义）
struct position;{
double lon;
double lat;
};
typedef struct{
double lon;
double lat;} position;
两种方法等价，下面的方法将position定义为struct{double lon;double lat;}
3、类
class、this、friend、private、protected、virtual、operator
#include<iostream>
using namespace std;
/**********************test基类*********************************/
class test{
public: //公共权限，可以被类中函数、友元函数、子类函数、类的对象访问
test();
~test();
void test1();
int n1 = 0;
virtual void virtual_test(); //虚函数
friend void test3(test a); //友元函数，并不是成员函数，只是在类中声明。用法相对固定，可以调用一个类中的私有变量
int operator+(const test& ps) //重载预算符号
{
return this->n1 + ps.n1;
}
protected: //保护权限，可以被类中函数、友元函数、子类函数访问
void test2();
int n2;
private: //私有权限，可以被类中函数、友元函数访问
int n3;
};
test::test(){
this->n3 = 10;
this->n1 = 3;
std::cout << "base class start" << endl;
}
test::~test(){
std::cout << "base class over" << endl;
}
void test::test1(){
std::cout << "test1" << endl;
}
void test::test2(){
std::cout << "test2" << endl;
}
void test3(test a){
std::cout << "test3:" << a.n3 <<endl;
}
void test::virtual_test(){
std::cout << "virtual test base" << endl;
}
/**********************test衍生类*********************************/
class test11 : public test{
public: //公共权限，可以被类中函数、友元函数、子类函数、类的对象访问
test11();
~test11();
// void virtual_test();
virtual void virtual_test();
};
test11::test11(){
std::cout << "subclass start" << endl;
}
test11::~test11(){
std::cout << "subclass over" << endl;
}
void test11::virtual_test(){
std::cout << "virtual test" << endl;
}
int main(){
std::cout << "start define" << endl;
test A;
test11 A1;
test A2;
std::cout << "start use" << endl;
A.test1();
// A1.test2(); //无法通过，因为保护函数只有在衍生类内部才能使用
A1.virtual_test();
std::cout << "operator:" << A+A2 <<endl;
test3(A);
return 0;
}
start define //程序开始
base class start //A的构造函数
base class start //A1的基类的构造函数
subclass start //A1本身的构造函数
base class start //A2的基类的构造函数
start use //开始
test1 //A1的public成员函数
virtual test //虚函数
operator:6 //运算符重载
test3:10 //友元函数
base class over //A的析构函数
base class over //A1的基类的析构函数
subclass over //A1本身的析构函数
base class over //友元函数的参数赋值了A，所以再次调用A的析构函数
base class over //A2的析构函数
三、复杂关键字（4个）
复杂，不太好理解，但有必要会的关键字
1、手动分配内存（new和delete）
#include <iostream>
int main()
{
int* pi = new int(5);//表示动态分配一个int ，初始化为 5
int* pa = new int[5];//表示动态分配一个数组，数组大小为5
std::cout << "pi_path:" << pi << std::endl;
std::cout << "pi_value:" << *pi << std::endl;
delete pi;
delete[] pa;
std::cout << "pi_path:" << pi << std::endl;
std::cout << "pi_value:" << *pi << std::endl;
return 0;
}
pi_path:0xef1720
pi_value:5
pi_path:0xef1720
pi_value:15669904
（1）函数流程
new和构造函数的顺序
先分配内存空间–malloc()。
再调用构造函数。
delete和析构函数的顺序
先调用析构函数。
再释放内存空间–free()。
（2）悬空指针
在释放内存之时，不应该仅仅是将该块内存进行释放，还要将指向该块内存的指针置为NULL。如果不置为NULL，该指针将变成悬空指针，下次继续使用该指针时会出现问题。
总之，free或者delete只是将指针变量指向的内存进行释放，却并没有对指针变量本身做任何操作。
2、模板（template）
#include <iostream>
template <typename T> int compare (T& t1, T& t2);
template <typename T>
int compare(T& t1, T& t2)
{
if(t1 > t2)
return 1;
if(t1 == t2)
return 0;
if(t1 < t2)
return -1;
return 2;
}
int main()
{
int a = 1;
int b = 2;
int result = compare<int>(a,b);
std::cout << "result:" << result << std::endl;
return 0;
}
result:-1
3、异常（throw、try、catch）
#include<iostream>
using namespace std;
int divide(int a,int b){
if(b==0){
std::cout << "123" << endl;
throw 11;
}
else if(b>a){
std::cout << "456" << endl;
throw 22;
}
return a/b;
}
int main(){
try{
cout<< "result is " << divide(10,5)<<endl
<< "result is " << divide(10,0)<<endl
<< "result is " << divide(18,2)<<endl;
}
catch(const int err){
if(err == 11){
std::cout << "divide 0" << endl;
std::cerr<<err<<endl; //std::cerr标准错误流异常输出
}
else if(err == 22){
std::cout << "b > a" << endl;
std::cerr<<err<<endl;
}
}
catch(const float err){
std::cerr<<err<<endl; //std::cerr标准错误流异常输出
}
return 0;
}
result is 2
result is 123
divide 0
11
四、冷门关键字（4个）
估计用不上，但要能看懂的关键字
register： 将变量尽可能存储在cpu的寄存器而不是内存中，提升效率
inline： 不会将函数直接编译成指令，而是直接插入到调用处再编译，可以减少调用次数。
asm： 在c++中插入汇编
723
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
