////结构体的大小
//
////struct myStr {
//////    int c;
//////    double a;
//////    char b;    24
////
////    double a;
////    char b;
////    int c;//     16
////    void go(){
////        cout<<'h'<<endl;
////    };
////};
////
//////结构体的存储分配
////
////
//////如果sizeof一个引用，这个sizeof直接作用于引用的对象
////
////
////
////struct myStr1 {
//////    int c;
//////    double a;
//////    char b;    24
////
//////    double & a;
//////    char  & b;
////    int  & c;//     16
////    void go(){
////        cout<<'h'<<endl;
////    };
////};
//////sizeof类中的引用时,是指针的值(64位是8)
////int main(){
////    cout<< sizeof(myStr1)<<endl;        //8
////    int a = 10;
////    int &ra = a;
////    cout<< sizeof(ra)<<endl;            //4
////
////    return 0;
////}
//
////大小是8，因为函数储存在代码区,不计入sizeof

////newdelete全局重载
//
//
////在维护大型项目中需要
////局部new其实还是调用了全局new,分配内存还是全局new完成
////类内部的new没有完成分配内存的工作,只是做了一个劫持
//
////class MyClass{
////
////};
////int main(){
////    cout<<"size of myclass: "<< sizeof(MyClass)<<endl;
////    //sizeof(MyClass) 1,表明存在
////    return 0;
////}
////空类占一个字节
//
//
////class MyClass{
////    int a;
////};
////int main(){
////    cout<<"size of myclass: "<< sizeof(MyClass)<<endl;
////    //sizeof(MyClass) 4
////    return 0;
////}
//
////class MyClass{
////    int a;
////    MyClass(){
////        a = 10;
////    }
////};

////void *operator new (size_t size){
////    cout<<"全局new重载"<<endl;
////    if(size == 0){
////        return 0;
////    }
////    void *p = malloc(size);
////    return p;
////}
////
////void operator delete(void * p){
////    cout<<"全局delete重载"<<endl;
////    free(p);
////}
////
////int main(){
////    int * p = new int(4);
////    delete p;
//////    MyClass * CC = new MyClass();
////    return 0;
////}
//
////创建的时候是局部new---全局new---malloc---调用构造函数
////销毁的时候是
//
//
//class tansheng {
//public:
//    int *p;
//    int length;
//public:
//    tansheng()//构建的时候初始化
//    {
//        std::cout << "构造函数谭胜被创建" << std::endl;
//    }
//
//    ~tansheng()//删除的时候释放内存
//    {
//        std::cout << "析构函数谭胜被销毁" << std::endl;
//    }
//
//    static void *operator new(size_t size) {
//        std::cout << "局部new0" << std::endl;
//        tansheng *ptemp = ::new tansheng;//劫持
//        std::cout << "局部new1" << std::endl;
//        return ptemp;
//    }
//    static void operator delete(void *p) {
//        std::cout << "局部delete" << std::endl;
//        ::delete p;//::全局
//    }
//
//
//    //添加局部new用于数组上
//    static void *operator new[](size_t size) {
//        std::cout << "局部数组new0" << std::endl;
//        void * p = operator new(size);
//        std::cout << "局部数组new1" << std::endl;
//        return p;
//    }
//    static void operator delete[](void *p) {
//        std::cout << "局部数组delete" << std::endl;
//        return operator delete(p);
//    }
//};
//
//void *operator new (size_t size){
//    cout<<"全局new"<<endl;
//    if(size == 0){
//        return 0;
//    }
//    void *p = malloc(size);
//    return p;
//}
//
//void operator delete(void * p){
//    cout<<"全局delete"<<endl;
//    free(p);
//}
//
//int main2(){
//
//
//    tansheng * p = new tansheng();
//
//
//
//    delete(p);
//    return 0;
//}
//
///*
// *
//局部new对象被创建0
//全局new重载
//构造函数谭胜被创建
//局部new对象被创建1
//构造函数谭胜被创建
//析构函数谭胜被销毁
//局部delete对象被销毁
//全局delete重载
// *
// *
// * */
////构造函数谭胜被创建 有两次为什么
//
//
////全局的new 和delete监视所有的
//
//
////如果是数组,全局重载
//
//void *operator new[](size_t size){
//    cout<<"数组全局new"<<endl;
//    return operator new (size);//每个对象挨个调用
//}
//void operator delete[](void*p){
//    cout<<"数组全局delete"<<endl;
//    return operator delete(p);//每个对象挨个调用已经重载好的delete
//}
//int main3(){
//
//    tansheng * p = new tansheng[5];
////    tansheng * p1 = new tansheng[5]();是什么意思?
//
//
//    delete []p;
////    delete p;//对于基本类型可以这样,但是非基本类型不可以
//
//}

////大数乘法与结构体
//
//
//
////C语言结构体和C++结构体的区别
//
//
//
struct MyStruct1 {
    int num1;
    int num2;

    void gogo() {

    }
};

//可以继承
//可以有权限控制
//
int main66() {
//    MyStruct1 s1;
//    struct MyStruct1 ss;
    //有没有struct
    return 0;
}



//函数模板以及自动数据类型


//T是通用数据类型
template<typename T>
T Max(T *p, const int n) {
    T maxdata(p[0]);
    for (int i = 0; i < n; ++i) {
        if (maxdata < p[i]) {
            maxdata = p[i];
        }
    }
    return maxdata;
}


//int getAll(int n,...){
//
//}


//处理可变长参数需要使用
#include <iostream>
#include "cstdarg"
template<typename NT>
//参数至少要有一个是模板类型?
//NT date1没有什么用处就是做一个标志
NT sum(int num,NT date1,...) {
    va_list arg_ptr;//参数列表指针
    va_start(arg_ptr,num);//限定从num开始,限定多少个参数
    NT sumres(0);
    for (int i = 0; i < num; ++i) {
        sumres+=va_arg(arg_ptr,NT);
    }
    va_end(arg_ptr);//结束
    return sumres;
}

int main32() {
    std::cout<<sum<int>(5,1,2,3,4,5)<<std::endl;
    std::cout<<sum<double>(5,1.2,2.2,3.2,4.2,5.3)<<std::endl;

}


//auto与函数模板

//函数参数不能使用auto,而
//auto get(int data,double bigdata)-> decltype(data*bigdata){
//
//}



//自动数据类型,根据实际推导出类型
template<class T1, class T2>//根据类型获取类型
auto get(T1 t1, T2 t2) -> decltype(t1 * t2) {

};


//宽字符
//本地
#include "locale"
int main12312(){
    setlocale(LC_ALL,"chs");//设置本地化
    wchar_t  *p = L"123456";
    wchar_t  *p1 = L"你好23456";
    std::wcout<<p<<std::endl;
    std::wcout<<p1<<std::endl;


    return 1;
}

//inline函数
//和define效果一样
//但是define无法保证类型安全

#include "iostream"
#define GETX3(N) N*N*N
//内联函数,会在内部展开,相对于define类型安全
inline int getx3(int n){
    return n*n*n;
}

//inline使用模板化
template<typename T>
inline T getX2(T t) {//类型不匹配会出错,不是单纯的替换
    return t * t;
}

//inline只是对编译器的建议
/*
 * 一般情况下我们队内联函数做出以下限制
 * 不能有递归
 * 不能包含静态数据
 * 不能包含循环
 * 不包含数组
 * 不包含goto和switch
 *若一个内联函数不满足以上限制,编译器会把它当做普通函数
 *
 *
 *
 *
 * */
//
//int main(){
//    std::cout<<GETX3(1+2)<<std::endl;
//    //7------1+2*1+2*1+2
//    return 1;
//}





//c和c++的不同

/*
 * 常量表示方法不同
C 语言不支持引用的概念，而 C++支持
 注释不同，C89 不支持单行注释
 （++i) ++在 C 中不合法
 （a=3) =4 在 C 中不合法,而在这种情况下c++会将(a=3)转换成左值 a=4 c++检测右值在内存中有实体,会自动转换成左值.c语言不会把左值转换为右值

 不能在 for 循环头部定义变量
 *
 *
 *
 * */



//c语言中全局变量有声明和定义之间的区别

//c++中这样是错误的,全局变量没有声明的定义之间的区别
//int c;
//int c;
//int c;

//static全局变量
//c语言可以,c++错误
//静态全局变量没有声明的定义之间的区别
//static int vv;
//static int vv;


//因为c++是强类型的,所以函数返回值必须要有类型main()

int main2222(){
    int  a =3;
    (++a)++;
//    (a+1)++; a+1在内存中没有实体 在寄存器中计算出来
    return 0;
}

//寄存器变量
int main33(){
    register int a(10);
    //register做了优化,其实也是建议,可以取地址
    //c中是不行的
    std::cout<<&a<<std::endl;
}

//c++编译器的宽泛,c中就不可以
//为了修改源代码,后面留下拓展
//占位
void test(int a , double, double){

}


//delete以后尽量设置为NULL
int main(){
    int *p = new int(5);
//    delete p;
//    p = NULL;防止重复删除
//    delete p;
    return 1;
}

typedef unsigned short wchar_t;

typedef wchar_t WCHAR

wchar_t * a(L"china");

namespce {
    char c;
    int i;
    double d;
}

namespace __UNIQUE_NAME_ {
    char c;
    int i;
    double d;
}
using namespace __UNIQUE_NAME_;

namespace a = mySpace;

void printf(int c,int a = 5){
    std::cout<<a<<endl;
}

void printf(int c){
    std::cout<<c<<endl;
}
int main(){
//    printf(6);
    //此时会有歧义,所以要用函数指针调用
    void (*p1)(int c, int a) = printf;
//    void (*p2)(int c) = printf;
//    void (*pp)(int c) = printf;
    p1(6,7);
    //参数需要补全,函数指针没有默认参数,需要全部输入数据,如果想使用默认参数特性最好使用命名空间去解决这个问题
    return 0;
}

void printf(int c,int a = 5){
    std::cout<<a<<endl;
}

void printf(double c){
    std::cout<<c<<endl;
}
int main(){
    printf(6);
    return 0;
}

一个引用符引用左值,两个引用符引用右值

int& getA(){
    int a = 10;//a在栈上,
    int&ra = a;
    return ra;
}
int main(){
    int & ra = getA();
    std::cout<<ra<<endl;
    std::cout<<"hello"<<endl;
    std::cout<<ra<<endl;
    /*
     * 10
     * hello
     * 32767
     * */
    return 1;
}

int* & getA(){
    int * p = new int(5);
    int * &rp = p;
    return rp;
}
//返回引用指针
int main(){
    int *& ra = getA();
//    int *p = ra;使用一个变量接着,
        int * p1 = ra;


    std::cout<<*ra<<endl;
    std::cout<<*p1<<endl;
    std::cout<<"hello"<<endl;
//    delete (p1);
    std::cout<<*p1<<endl;
    std::cout<<*ra<<endl;
    //c++删除内存后禁止访问,而且指针
    delete(*p1);
    std::cout<<p1<<endl;
    std::cout<<*p1<<endl;
    std::cout<<*ra<<endl;
    /*
     * 10
     * hello
     * 32767
     * */
    return 1;
}

int main(){
    const int num = 5;
    int *p = (int *)#
    *p = 2;
    std::cout<<num<<endl;
}
//所得结果仍然是5,因为int *p = (int *)&num;()强转是C语言的转换方式
//虽然编译成功但是c++不会执行这段代码?还是执行了但是维护了一个常量表,通过 VS 反编译看看吧
int main(){
    const int num = 5;
    int *p = const_cast<int*>(&num);
    *p = 2;//编译通过,但是貌似并没有起作用
    std::cout<<num<<endl;
}

int main(){
    int a = 10;
    const int b =5;
//    int const * p1(&a);//经常使用这种形式,用于限定权限(所以不会严格的检查类型),只能读不能写,所以可以操作
//    const int * p2(&a);
//    *p1 = 3;
//    *p2 = 6;
        // const在*左边,指向常量的指针变量,常量指针,不能改变指向的值
                int * const p1(&a);
                //指向变量的指针
                int * const p2(&b);//cannot initialize a variable of type 'int *const' with an rvalue of type 'const int *'
//&b是 const int * p2是一个指向变量的指针常量

//    const int * p2;
//
//    int * const pp;
//    const int const * p3;


}

int select(const int &rum){
//    rum--;
    return rum;
}


int main(){
    const int num1 =10;
    int num2 = 20;
    std::cout<<select(num2)<<endl;
    return 1;
}

//真实的内存已经被修改,从常量表里获取了值
//const 编译器会优化,不会从内存读取

 int main(){
     //不能 delete两次

//    int a[10];
//    int * p = a;
//    int i = 0 ;
//    for (auto date:p){
//
//    }
    int *p = new int[10];
    int i = 0;
    for (int j = 0; j < 10; ++j) {
        std::cout<<p[j]<<endl;
    }
    std::cout<<endl;
    for (int j = 0; j < 10; ++j) {
        p[j] = i++;
        std::cout<<p[j]<<endl;
    }
    std::cout<<endl;
    std::cout<<p<<endl;
    delete []p;//删除数组的空间,基本数据类型可以直接 delete, 复杂类型必须[]
    std::cout<<p<<endl;
//    for (int j = 0; j < 10; ++j) {
//        std::cout<<p[j]<<endl;
//    }

    return 1;
 }

int main(){
    int *p = new int[80];
    int (*px) [10] = (int (*) [10])p;
//new只能分配线性

//    px[i][j];
    return 1;
}