数据类型转换

//static_cast<int>(10.1) 静态转换不适应于指针 <>要转换的类型 ()要转换的数据
//reinterpret_cast<void>( pchar+i) 用于指针类型转换 C语言直接赋值
//涉及const 必须要用 const_cast<int>

//dynamic_cast<huahua*>(pzi); //dynamic_cast用于安全的转换父类对象与子类对象如果不匹配转换失败为null
//主要用于多态依赖于虚函数

//父类
class huahua
{
public:
    int hua1;
    virtual void run()
    {
        cout << "hhhhhhh" << endl;
    }


};
//子类
class xiaohua:public huahua
{
public:
    int xiaohua1;
    void run()
    {
        cout << "xxxxhhhhhhh" << endl;
    }

};

void mainr1()
{
    //printf("%d",10.1); //垃圾值 printf不会完成数据类型转换
    //printf("%d", static_cast<int>(10.1)); //默认转换

    //int*pint = new int(1);
    //char*pchar = reinterpret_cast<char*>(pint); //指针类型转换
    //for (int i = 0; i < 3; i++)
    //{

    //  cout << static_cast<int>(*(pchar + i)) << "  "<<reinterpret_cast<void*>( pchar+i) <<endl;
    //}

    int num[5]{ 1,2,3,4,5 };
    const int *p = num;
    //int*pint = reinterpret_cast<int*>(p); // reinterpret_cast 不适用于const
    int*pint = const_cast<int*>(p);
    //for (size_t i = 0; i < 5; i++)
    //{
    //  cout << pint[i] << "  " << reinterpret_cast<void*>(pint + i) << endl;
    //  
    //}

    //父类指针可以经过转换访问子类对象 反之一般不安全

    huahua *pfu = new huahua;
    xiaohua *pzi = new xiaohua;
    
    huahua *phua = dynamic_cast<huahua*>(pzi); //子类对象转换为父类指针
    phua->run();

    xiaohua *pxiaohua = dynamic_cast<xiaohua*>(pfu); //转换失败 会设置为null
    if (pxiaohua != nullptr)
    {
        pxiaohua->hua1 = 10; //访问子类继承父类的对象
        pxiaohua->run();
        (*pxiaohua).huahua::run(); //调用子类中的父类的方法
    }

    cin.get();
}

delete删除一个函数

void show(int num)
{
   cout << num << endl;
}
void show(char num) = delete; //删除一个函数
//函数声明=delete
// 精确匹配  删除其他参数匹配类型函数


class myclass
{
public:
   //myclass() = delete; //删除构造函数
   ~myclass() = delete;
};

大括号处理数据

#include<initializer_list>

void show(initializer_list<int>list)
{
    for (auto i : list)
    {
        cout << i << endl;
    }
}

void show(initializer_list<char*>list)
{
    for (auto i : list)
    {
        cout << i << endl;
    }
}

int*getmem(initializer_list<int>list)
{
    int length = list.size();
    int *p = new int[length];
    int*pback = p; //备份指针
    for (auto i : list)
    {
        *(p++) = i; //循环赋值
    }
    return pback;
}

void mainr2()
{
    show({ 1,2,3,4,5,6 });
    show({"DDD","eeee","FFFFF","dddd"});

    int*p = getmem({ 1,2,3,4,5,6 });
    for (size_t i = 0; i < 6; i++)
    {
        cout << p[i] << " ";
    }
    cout << endl;

    cin.get();
}

forward_list


#include<forward_list>

void mainr3()
{
    forward_list<int>list1{ 1,2,3,4,5 };
    forward_list<int>list2{ 1,2,3,4,5 };
    //list1.push_front(10); //只能头插


    list2.assign(10,19); //分配并初始化

    //for (auto i : list1)
    //{
    //  cout << i << endl;
    //}

    //auto it = list1.before_begin(); //链表头结点
    //list1.insert_after(it, 18); //链表的插入

    auto ib = list1.begin();
    list1.insert_after(ib, 19);

    int a[5]{ 1,2,3,4,5 };
    list1.insert_after(ib, a, a + 5); //插入
    list1.erase_after(++ib); //删除

    list1.sort();  
    list2.sort();
    list1.merge(list2);//归并

    cout << list1.max_size() << endl; //最大

    list1.reverse(); //反转

    for (auto ib = list1.begin(), ie = list1.end();ib != ie;ib++)
    {
        cout << *ib << endl;
    }



    cin.get();
}

if_exits

#include<iostream>
#include<list>

//类模板
template<class T>
class Tclass
{
public:
    T t;
    void show(T tx)
    {  
        cout << tx << endl;
    } 



};


void main()
{
    
    //int num;

    Tclass<int> t1;
    list<int> mylist;   //检测某个模板有没有根据类型实例化


    _if_exists(Tclass<int>)  //如果存在 执行块语句  可以判断变量 函数 类型
    {
        cout << "num is" << endl;
    }

    _if_not_exists(Tclass<int>)
    {
        cout << "num no" << endl;
    }

    cin.get();
}

引用包装器


void change(int &num)
{
    num = 3;
}

template<class T>
void show(T t)  //函数模板 改成引用
{
    cout << t << endl;
    t++;
}
void main()
{
    double db(1);
    double &rdb(db);
    show(ref(db));  //ref  引用包装器  让模板识别出引用

    cout << db << endl;

    cin.get();
}