cout<<"Standard Clib: "<< __STDC_HOSTED__<<endl;        //Standard Clib: 1(指定编译器目标系统是否包含完整的C库)

    cout<<"Standard C: "<<__STDC__<<endl;                   //__STDC__:1(指定编译器目标系统是否与C标准一致)

    //cout<<"C Standard Version: "<<__STDC_VERSION__<<endl; //测试gcc 没有定义(支持标准C库的版本)

    //cout<< "ISO/IEC: "<<__STDC_ISO_10646__<<endl;         //测试gcc 没有定义

const char * Stanard_Macros(void)

{

    //......

    return __func__; //返回值:Stanard_Macros

}    

//头文件防止重复包含

#pragma once;

_Pragma("once");    

#define PRAGMA(x) _Pragma(#x)    //宏命令中使用#可以实现替换字符串化

PRAGMA(once);

//__FILE__当前文件路径

//__LINE__当前文本行

#define LOG(...){ \

    fprintf(stderr, "%s: Line %d:\t", __FILE__, __LINE__);\     //输出错误的文件及行号地址

    fprintf(stderr, __VA_ARGS__);\         　　　　　　　　　　　　//输出错误的数据

    fprintf(stderr, "\n");  \

}

LOG("%s", "NO ERR!"); // xxxx：xxxx: NO ERR!

    long long int lli = -90000000000LL;

    unsigned long long int ulli = 9000000000000ULL;

    cout<<"LLONG_MIN: "<<LLONG_MIN<<endl;                   //LLONG_MIN: -9223372036854775808

    cout<<"LLONG_MAX: "<<LLONG_MAX<<endl;                   //LLONG_MAX: 9223372036854775807

    cout<<"ULLONG_MAX: "<<ULLONG_MAX<<endl;                 //ULLONG_MAX: 18446744073709551615

static_assert(sizeof(b)==sizeof(a), "the parameters of bit_copy must have same width"); //静态断言，编译器确定，返回false则触发告警信息

const char * Stanard_Macros(void) noexcept 　　　　//相当于noexcept(true), 如果有异常会发生，不会传播和扩散，编译会调用std::terminate()来终止程序运行

const char * Stanard_Macros(void) noexcept(false) //noexcept中可以为结果为bool型的表达式

class Mem{

public:

    Mem(int i): m(i){};

        ~Mem(){};

    const char *ShowMem(void){  std::cout<<"Mem: "<<m<<" ";

                                return __func__;

                            };

private:

    int m{};

};

//快速初始化

//初始化列表优于就地的列表初始化

class Init{

public:

    Init(): a(){};       Init(int d): val('G'), a(d){}; //初始化列表实际效果后作用，效果上优于列表初始化

//      ~Init(){ throw 1; };

        ~Init(){};

    const char * showPara(std::string str);

    int a;

private:

    char val{'g'};       　　　　　　//成员变量的快速初始化

    Mem mem{};

    std::string name{"Init"};

};

//C++的成员变量快速初始化

Init init1{};                //C++11的统一列表初始化

Init init2;

init1.showPara("init1: ");    //init1: 5 init1: G name :Init Mem: 1 mem :ShowMem

init2.showPara("init2: ");    //init2: 0 init2: g name :Init Mem: 1 mem :ShowMem        

    cout<<"Dyna Sizeof: "<<sizeof(((Init *))->a)<<endl;    //C++98时借用实例对象获得非静态成员长度

    cout<<"Dyna Sizeof: "<<sizeof(Init::a)<<endl;           //C++11支持直接获得

class People;

template<typename T> class Ploy;

template<typename T>

class Ploy{

public:

    friend T;    //指定类的友元类，允许友元类访问本地参数

private:

    string m{"smart"};

};

class People{

public:

    void ShowPara(Ploy<People> *p){

        cout<<"Ploy Data: "<<p->m<<endl;

    }

};

//friend的扩展用法

Ploy<People> ppe;

People Pe;

Pe.ShowPara(&ppe);

class MathObject{

public:

    virtual double Arith() = ;

    virtual void Print() = ;

};

class Printable:public MathObject{

public:

    double Arith() = ;         //纯虚函数仅允许为0

    void Print() final{

        std::cout<<"Output is: "<< Arith() <<std::endl;

    }

};

class Add2:public Printable{

public:

    Add2(double a, double b):x(a), y(b){}

    double Arith() override{    //override指定函数为派生类的override(覆盖)函数，会进行检查

        return x+y;

    }

//    void Print(){}            //编译会报错，因为父类声明了final，子类不允许重载

private:

    double x, y;

}

//类模板 C++98就允许，不过定义有要求

template<typename T1, typename T2 = int>class DefClass1{};      //允许，指定类模板的默认模板参数

//template<typename T1 = int, typename T2> class DefClass2;     //通不过编译，多个默认模板参数指定默认值时，必须遵守从右向做的原则

//函数模板 C++11添加

template<typename T1, typename T2 = int>void DefFunc1(T1 a, T2 b);

template<typename T1 = int, typename T2>void DefFunc2(T1 a, T2 b); //允许

//sundry.h

template <typename T>void fun(T) {}    //模板函数定义

//sundry1.cpp

template void fun<int>(int);           //模板实例化声明

//sundry2.cpp

extern template void fun<int>(int);    //模板外部声明

template<typename T> class X{};

template<typename T> void TempFunc(T t){};

struct {int i;}b;

typedef struct{int i;}B;

struct C{} c;

X<B> x1;   　　　　//匿名结构体作为实参，不过只支持别名，不支持匿名结构体直接作为实参

X<C> x2;  　　　　 //局部变量作为实参

TempFunc(b);  　　//匿名类型变量，C++11允许

TempFunc(c);   　 //局部类型变量，C++11允许