---

【1】extern “C”

extern "C"  //用于连接指定路径 以C语言方式去编译
{
    #include "exhead.h"
}

【2】asm

asm :asm允许你在你的代码中直接插入汇编语言指令， 各种不同的编译器为这一个指令允许不一致形式, 比如：

asm {
       instruction-sequence	//指令顺序
}
asm( instruction );//插入汇编指令

【3】关键字auto

是用来声明完全可选择的局部变量的 自动转为对应数据类型

【4】break语句

只能跳出本层循环,假如你要跳出一个三重嵌套的循环,你就要使用包含其它的逻辑或者用一个goto语句跳出这个嵌套循环.

【5】catch 语句

通常通过 throw 语句捕获一个异常.

【6】关键字class

允许你创建新的数据类型. class-name 就是你要创建的类的名字

【7】关键字const

用来告诉编译器一个一旦被初始化过的变量就不能再修改.

【8】#if

#if defined TEST  //如果定义了TEST宏
    #pragma message  "这里打印TEST=10" 
    //自定义编译信息   //编译时看见，运行的时候是看不见的  通过：g++ -E main.cpp -o mian.i 查看预处理文件
#endif

【9】#pragma once

用于头文件只能被编译一次,这个文件不小心写了两次头文件 在这个头文件哪里定义可以解决

【10】#pragma pack(1)

在结构体 用于指定内存对齐的标准 pack(1)

typedef struct info
{
    int a;  //4
    char d; //1
    //对齐：a:4: 1 1 1 1  d:1 :1     以1为对齐的最小值  超过的往后排布 4+1=5  
}node_t;

【11】#pragma pack(4)

一般对齐标准不能超过4字节

typedef struct info1
{
    int a;  //4
    node_t d; //4
    float b; //4
    double c; //8
    //对齐：4+8+4+8=24
}node_1;

【12】explicit

explicit

当构造函数被指定为explicit的时候,将不会自动把构造函数作为转换构造函数 防止隐式类型转化，编译器自动调用拷贝初始化的行为 ；
这仅仅用在当一个初始化语句参数与这个构造函数的形参匹配的情况. 例子：

 AA(int a){cout<<"call me"<<endl;}
 void  f( AA cp) {}   //外部函数  
 int main(){
     f(1);  //被隐式转化为F(AA(1)),本来是1变成了AA(1)是拷贝初始化 call me被打印
 }

【】 continue语句

用来结束这次循环在一个循环语句中(跳过当前循环，不是跳出循环)
例如,下面这段代码会显示所有除了0之外0-4的所有数字:

for( int i = 0; i < 5; i++ ) {
 if( i == 2 ) {
   continue;
 }
 cout << i << " "<<endl;
}

【13】关键字enum

用来创建一个包含多个名称元素的名称表.var-list 是可选的. 例如:

enum color {red, orange, yellow, green=6, blue, indigo, violet}; //类似：{0,1,2,3,4,...........}
color c1 = indigo;  //定义枚举变量c1：   判断是否和枚举里面的值相等
if( c1 == indigo ) {
  cout << "c1 is indigo  :" <<indigo<< endl; //8
}
cout<<red<<endl;  //直接打印枚举值  0
cout<<green<<endl;  //注意注意：这里对枚举值进行了初始化，后面的值在这个值上递增 6
cout<<blue<<endl;  //7
cout<<sizeof(color)<<endl;  //4字节
cout<<sizeof(c1)<<endl;  //可以发现枚举大小是4字节

【14】friend

关键字friend: 允许类或函数访问一个类中的私有数据（函数和变量）. (友元类、 友元函数)

【15】goto语句

可以完成从当前位置到指定标志位的跳转.使用goto语句要考虑有害性,所以它不经常使用.
常用：出错时结束当前函数
例如,
goto可以用来跳出多重嵌套 for 循环,它比额外的逻辑性跳出更具有时效性.

【16】关键字inline

请求编译器给一个函数扩展空间,它向这个函数发出一条插入代码的call.
当函数里面有 static 数据, 循环, switches, 或者是递归的时候不给予内联.
当一个函数声明包含在一个类声明里面时,编译器会尝试的自动把函数内联.

【17】关键字mutable

忽略所有const 语句.一个属于const对象的mutable 成员(类里面的私有变量)可以被修改.
在类里面定义mutable int a; 类里面有一个函数，
int fun() const; //函数内的数据类型只能是只读，但是现在: a可以再只读函数里面++ –
等操作 sh->fun(); //a=2

【18】关键字namespace

  namespace name {
    declaration-list;
  }

关键字namespace允许你创建一个新的空间.名字由你选择,忽略创建没有命名的名字空间.一旦你创建了一个名字空间,
你必须明确地说明它或者用关键字using. 例如:

namespace CartoonNameSpace {
  int HomersAge;
  void incrementHomersAge() {
    HomersAge++;
  }
}
int main() {
  ...
  CartoonNameSpace::HomersAge = 39;  //通过空间名初始化和函数调用， ：：（域运算符）  保证数据的安全性
  CartoonNameSpace::incrementHomersAge();
  cout << CartoonNameSpace::HomersAge << endl;
  ...
}

【19】关键字operator 用于重载函数

对于一元的操作, parameter-list(参数列表) 应当为空 对于二元的操作,在operator右边的
parameter-list(参数列表) 应当包含操作数 (在operand 左边的被当作 this通过). 你不能用#, ##, .,
:, .*, 或者 ? 标志重载.

【20】private

属于私有类的数据只能被它的内部成员访问,除了friend 使用.
关键字private
也能用来继承一个私有的基类,所有的公共和保护成员的基类可以变成私有的派生类.

【21】protected

保护数据对于它们自己的类是私有的并且能被派生类继承.

关键字keyword 也能用于指定派生,所有的公共和保护成员的基类可以变成保护的派生类.

【22】public

在类中的公共数据可以被任何人访问.关键字public也能用来指定派生, 所有的公共和保护成员的基类可以变成保护的派生类.

【23】register 关键字

register 请求编译器优化它定义的变量,并且通常这种优化比人工优化的好.

register int mn=100; //寄存器优化
cout<<"mn="<<mn<<endl;

【24】reinterpret_cast (obj)

操作能把一种数据类型改变成另一种.它应当被用在两种不可调和的指针类型之间.
type-id:必须是一个指针、引用、算数类型、函数指针、成员指针；注意：没有进行二进制的转换

【25】static_cast (object)

关键字static_cast 用来在两个不同类型之间进行强制转换,并且没有运行时间检查.

static int kk=97;
char nn = static_cast<char >(kk); //'a'=97  //将静态变量转化为其他类型
cout<<"nn="<<nn<<endl;

【26】Template关键字

能用来创建一个对未知数据类型的操作的函数模板.这个通过用其它数据类型代替一个占位符data-type 来实现.

【27】关键字typename

能用来在中 template 描述一个未定义类型或者代替关键字class. template ;
template

【28】关键字 this

指向当前对象.所有属于一个 class 的函数成员都有一个this 指向.

【29】关键字typedef | typeid

允许你从一个现有的类型中创建一个新类型.
typeid( object ); typeid 操作返回给一个type_info 定义过的对象的那个对象的类型.

typedef int DATA;
DATA ff=100;
cout<<"ff="<<ff<<endl;
double i;
//打印了变量的首个字符 ,,可以判断变量类型
float f;
cout<<"i的类型是"<<typeid(i).name()<<endl;
cout<<"f="<<typeid(f).name()<<endl;

【30】Union 联合体

：类似于 class,除了所有的成员分享同一内存外它的缺省值更像公共类型. 例如:

union Data {
  int i;
  char c;
};    //用谁其他就被覆盖

【31】volatile 关键字

:volatile在描述变量时使用,阻止编译器优化那些以valatile修饰的变量
volatile被用在一些变量能被意外方式改变的地方,修饰的变量是变化无常的，但是需要变量的值赋值时，必须去变量的地址空间读取，在赋值给其他变量
例如:抛出中断 读写屏障 c常在线程中修饰变量 每一个线程都可以改变volatile修饰的变量，
为了实时更新改变的值，保证每一个线程准确无误的访问变量 ，所以使用关键字修饰变量 这些变量若无volatile可能会和编译器执行的优化相冲突.

---

【32】源码

#include <stdio.h>
#include <iostream>
#include <string.h>
#define TEST 10
extern "C"  //用于连接指定路径
{
    #include "exhead.h"
}
using namespace std;


//asm :asm允许你在你的代码中直接插入汇编语言指令， 各种不同的编译器为这一个指令允许不一致形式, 比如：
/*   
    asm {
            instruction-sequence
    }
    asm( instruction );


*/
//关键字auto是用来声明完全可选择的局部变量的 自动转为对应数据类型


//break语句只能跳出本层循环,假如你要跳出一个三重嵌套的循环,你就要使用包含其它的逻辑或者用一个goto语句跳出这个嵌套循环.


//catch 语句通常通过 throw 语句捕获一个异常. 


//关键字class允许你创建新的数据类型. class-name 就是你要创建的类的名字


//关键字const用来告诉编译器一个一旦被初始化过的变量就不能再修改.




#if defined TEST  //如果定义了TEST宏
    #pragma message  "这里打印TEST=10" //自定义编译信息   //编译时看见，运行的时候是看不见的  通过：g++ -E main.cpp -o mian.i 查看预处理文件
#endif
//#pragma once    //用于头文件只能被编译一次,这个文件不小心写了两次头文件  在这个头文件哪里定义可以解决


#pragma pack(1)   //在结构体  用于指定内存对齐的标准  pack(1)
typedef struct info
{
    int a;  //4
    char d; //1
    //对齐：a:4: 1 1 1 1  d:1 :1     以1为对齐的最小值  超过的往后排布 4+1=5  
}node_t;
#pragma pack(4)   //一般对齐标准不能超过4字节
typedef struct info1
{
    int a;  //4
    node_t d; //4
    float b; //4
    double c; //8
    //对齐：4+8+4+8=24
}node_1;
//dynamic:  主要用于类对象之间的强转
class AA
{
private:
    
public:
    explicit AA(/* args */)
    {
        cout<<"AA"<<endl;
        /*
            explicit 
            当构造函数被指定为explicit的时候,将不会自动把构造函数作为转换构造函数
            防止隐式类型转化，编译器自动调用拷贝初始化的行为
            这仅仅用在当一个初始化语句参数与这个构造函数的形参匹配的情况.
            例子：
            AA(int a){cout<<"call me"<<endl;}
            void  F( AA cp) {}   //外部函数  
            int main(){
                f(1);  //被隐式转化为F(AA(1)),本来是1变成了AA(1)是拷贝初始化 call me被打印


            }
        */
    }
    virtual ~AA()
    {
        cout<<"~AA"<<endl;
    }
    virtual void  eat()=0;  //纯虚函数
};


class BB:public AA
{
public:
    virtual void eat()  //重写父类方法
    {
        cout<<"压十啦你"<<endl;
    }
    void show(int a)
    {
        this->a =a;
        cout<<"show"<<endl;
    }
    BB(/* args */)
    {
        cout<<"BB"<<endl;
    }
    ~BB()
    {
        cout<<"~BB"<<endl;
    }
    void fun() const
    {
        ++a;  //本来a不能这样， mutable关键字修饰后可以
        cout<<"a="<<a<<endl;
    }
private:
    mutable int a; //a被修饰为一直可变
};


typedef union lenth {
    int i;
    char c;
    double d;
    long double ld;
}un;


int main(int argc, char const *argv[])
{
    auto  a='a';
    cout<<a<<endl;
    //throw 在C++体系下用来处理异常.同try 和 catch 语句一起使用, 
    //C++ 处理异常的系统给程序一个比较可行的机制用于错误校正.
    //当你通常在用 try 去执行一段有潜在错误的代码时.在代码的某一处,
    //一个throw 语句会被执行, 这将会从try的这一块跳转到catch的那一块中去. 例如: 


    try {
      cout << "Before throwing exception" << endl;
      throw 42; //到这里就结束了，可以测试段错误
      cout << "Shouldn't ever see this" << endl;
    }  


    catch( int error ) {
      cout << "Error: caught exception " << error << endl; //捕获到：error =42
    }
    const char atr[] ="123";
    const char *p=atr; //定义一个常量指针（const *） 指向常量字符串  p存放atr的地址 
    p="321";  //p可以指向其他  
    //a="8989";  //atr只读，无法修改 
    cout<<p<<endl;
    cout<<atr<<endl;
    char const * p1=atr;  //const在*的左侧，一般就说明是常量指针 指向可变
    cout<<p<<endl;
    cout<<atr<<endl;
    char arr[]="000000";
    char  *const p2 =arr; //指针常量（*  const）  p2指向一次后，不能在指向其他  
    cout<<arr<<endl;
    cout<<p2<<endl;
   // p2=&arr[1];   错误：向只读变量‘p2’赋值
    cout<<p2<<endl;
    arr[1]='1';  //数组赋值  覆盖原来的值那个
    cout<<arr<<endl; //打印全部  arr能不能修改看谁修饰他
    char *str = const_cast<char *> (atr);  //将只读字符串常量类型转化 被const修饰的变量名
    cout<<str<<endl;

   // continue语句用来结束这次循环在一个循环语句中(跳过当前循环，不是跳出循环)
   //例如,下面这段代码会显示所有除了0之外0-4的所有数字: 


    for( int i = 0; i < 5; i++ ) {
      if( i == 2 ) {
        continue;
      }
      cout << i << " "<<endl;
    }
    //default : switch 语句中的缺省条件. 

/*
    delete 
语法: 
  delete p;             //释放申请了一个
  delete[] pArray;      //释放申请了多个

delete操作用来释放p指向的内存.这个指针先前应该被 new调用过.上面第二种形式用于删除一个数组.
*/
/*
dynamic_cast<type> (object);


关键字dynamic_cast强制将一个类型转化为另外一种类型
并且在执行运行时时检查它保证它的合法性。如果你想在两个互相矛盾的类型之间转化时
cast的返回值将为NULL.
*/
//new BB() :BB继承AA 所以打印 AA BB构造函数    一般是多继承  
AA *obj =new BB(); //注意 注意 注意：new才会创建对象  这里父类是抽象类不能创建对象
//这里的意思是父类的指针指向子类对象
obj->eat();  //父类指针 调用 打印子类成员函数的值
BB* sh =dynamic_cast<BB*>(obj); //父类的指针转化为子类的指针
sh->eat();//子类指针 调用 打印子类成员函数的值
sh->show(1);//子类指针 调用 打印子类成员函数的值
delete obj;  //只释放了父类析构函数   解决办法： 将父类析构函数设置为virtual修饰的
//delete sh;  //:段错误，是类型转化  并没有new  所以报错

    //关键字enum用来创建一个包含多个名称元素的名称表.var-list 是可选的. 例如: 
    enum color {red, orange, yellow, green=6, blue, indigo, violet}; //类似：{0,1,2,3,4,...........}
    color c1 = indigo;  //定义枚举变量c1：   判断是否和枚举里面的值相等
    if( c1 == indigo ) {
      cout << "c1 is indigo  :" <<indigo<< endl; //8
    }
    cout<<red<<endl;  //直接打印枚举值  0
    cout<<green<<endl;  //注意注意：这里对枚举值进行了初始化，后面的值在这个值上递增 6
    cout<<blue<<endl;  //7
    cout<<sizeof(color)<<endl;  //4字节
    cout<<sizeof(c1)<<endl;  //可以发现枚举大小是4字节




    //extern:引用外部变量,注意外部变量已经定义，不要重复定义(extern "C":调用外部C标准头文件)
    extern   int values;  //在这里声明，声明可以多次，且没有分配空间 
    cout<<values<<endl;   //成功获取  自定义头文件里的100


    cout<<buf<<endl; //在其他文件声明且初始化，直接打印值（会有警告C++）


    //extern：声明函数，函数名本身指向二进制的函数地址，不加extern的函数是隐式的函数，也可以调用其他文件


    //#pragma pack(1)  :  看对齐后大小
    node_t info;
    cout<<sizeof(info)<<endl; //5
    node_1 size;
    cout<<sizeof(size)<<endl;  //对齐标准：4   包括node_t的大小   //24


    //friend 
    //关键字friend: 允许类或函数访问一个类中的私有数据（函数和变量）. (友元类、 友元函数)


    //goto语句: 可以完成从当前位置到指定标志位的跳转.使用goto语句要考虑有害性,所以它不经常使用.  常用：出错时结束当前函数
    //例如, goto可以用来跳出多重嵌套 for 循环,它比额外的逻辑性跳出更具有时效性. 




    //关键字inline: 请求编译器给一个函数扩展空间,它向这个函数发出一条插入代码的call.
    //当函数里面有 static 数据, 循环, switches, 或者是递归的时候不给予内联.
    //当一个函数声明包含在一个类声明里面时,编译器会尝试的自动把函数内联. 


    //关键字mutable : 忽略所有const 语句.一个属于const对象的mutable 成员(类里面的私有变量)可以被修改.
    //在类里面定义mutable int a;   类里面有一个函数，int fun() const;  //函数内的数据类型只能是只读，但是现在:
    //a可以再只读函数里面++ --  等操作
    sh->fun(); //a=2
   


/*
   namespace 
语法: 
  namespace name {
    declaration-list;
  }
关键字namespace允许你创建一个新的空间.名字由你选择,忽略创建没有命名的名字空间.一旦你创建了一个名字空间,
你必须明确地说明它或者用关键字using. 例如: 


    namespace CartoonNameSpace {
      int HomersAge;
      void incrementHomersAge() {
        HomersAge++;
      }
    }
    int main() {
      ...
      CartoonNameSpace::HomersAge = 39;  //通过空间名初始化和函数调用， ：：（域运算符）  保证数据的安全性
      CartoonNameSpace::incrementHomersAge();
      cout << CartoonNameSpace::HomersAge << endl;
      ...
    }
*/
    //关键字operator 用于重载函数.
    //对于一元的操作, parameter-list(参数列表) 应当为空 
    //对于二元的操作,在operator右边的 parameter-list(参数列表) 应当包含操作数 (在operand 左边的被当作 this通过).
    //你不能用#, ##, ., :, .*, 或者 ? 标志重载. 

    //private 属于私有类的数据只能被它的内部成员访问,除了friend 使用.
    //关键字private 也能用来继承一个私有的基类,所有的公共和保护成员的基类可以变成私有的派生类.

    //protected 保护数据对于它们自己的类是私有的并且能被派生类继承.
    //关键字keyword 也能用于指定派生,所有的公共和保护成员的基类可以变成保护的派生类.

    //public 在类中的公共数据可以被任何人访问.关键字public也能用来指定派生,
    //所有的公共和保护成员的基类可以变成保护的派生类.

    //register 关键字: register 请求编译器优化它定义的变量,并且通常这种优化比人工优化的好.
    register int mn=100; //寄存器优化
    cout<<"mn="<<mn<<endl;

    //reinterpret_cast <type-id>(obj)操作能把一种数据类型改变成另一种.它应当被用在两种不可调和的指针类型之间.
    //type-id:必须是一个指针、引用、算数类型、函数指针、成员指针；注意：没有进行二进制的转换

    //static 数据类型用来给变量创建永久存储空间.静态变量在函数间调用时保持他们的值不变.
    //当用在一个类中时,所有要用到静态变量的时候这个类将把这个变量镜像过去.
     
     //static_cast<type> (object);  关键字static_cast 用来在两个不同类型之间进行强制转换,并且没有运行时间检查.
     static int kk=97;
     char nn = static_cast<char >(kk); //'a'=97  //将静态变量转化为其他类型
     cout<<"nn="<<nn<<endl;




    //Template关键字:能用来创建一个对未知数据类型的操作的函数模板.这个通过用其它数据类型代替一个占位符data-type 来实现.
    //关键字typename能用来在中 template 描述一个未定义类型或者代替关键字class.  template <class T>  ; template<typename T> 




    //关键字 this 指向当前对象.所有属于一个 class 的函数成员都有一个this 指向. 


    //关键字typedef 允许你从一个现有的类型中创建一个新类型. 
    //typeid( object );  typeid 操作返回给一个type_info 定义过的对象的那个对象的类型. 
    typedef int DATA;
    DATA ff=100;
    cout<<"ff="<<ff<<endl;
    double i;
    //打印了变量的首个字符 ,,可以判断变量类型
    float f;
    cout<<"i的类型是"<<typeid(i).name()<<endl;
    cout<<"f="<<typeid(f).name()<<endl;
    
    /*
    Union 联合体：类似于 class,除了所有的成员分享同一内存外它的缺省值更像公共类型. 例如: 


    union Data {
      int i;
      char c;
    };    用谁其他就被覆盖
    */
   cout<<sizeof(un)<<endl;  //16  long double  X86-64:  8+8
    /*
    volatile 关键字: volatile在描述变量时使用,阻止编译器优化那些以valatile修饰的变量
    volatile被用在一些变量能被意外方式改变的地方,修饰的变量是变化无常的，但是需要变量的值赋值时，必须去变量的地址空间读取，在赋值给其他变量
    例如:抛出中断  <interrupt>  读写屏障  c常在线程中修饰变量  每一个线程都可以改变volatile修饰的变量，
    //为了实时更新改变的值，保证每一个线程准确无误的访问变量  ，所以使用关键字修饰变量
    这些变量若无volatile可能会和编译器执行的优化 相冲突.
    */
    return 0;
}
//输出：
PS C:\Users\Administrator\Desktop\C语言函数集合> ./a
a
Before throwing exception
Error: caught exception 42
321
123
321
123
000000
000000
000000
010000
123
0
1
3
4
AA
BB
压十啦你
压十啦你
show
~BB
~AA
c1 is indigo  :8
0
6
7
4
4
100
djfhj
5
24
a=2
mn=100
nn=a
ff=100
i的类型是d
f=f
16
PS C:\Users\Administrator\Desktop\C语言函数集合>