美文网首页
2018-05-06

2018-05-06

作者: try312 | 来源:发表于2018-05-07 23:48 被阅读0次

    auto

    //C++14自动推理返回值
    //C++11 需要返回->指定类型
    
    
    auto (*f)()  -> int(*)(); 
    //f是什么类型?
    int(*    (*fx)()   )( );    //返回值是函数指针
    
    
    auto pf(void) -> auto(*)(int x)  -> int(*)(int a,int b)
    {
        //层级运转方式: 从左往右
        return nullptr;
    } 
    //pf是什么类型?
    // auto pf(void) ->              auto(*)(int x)  ->               int(*)(int a,int b)
    // int (*           (*           pf(void)                )(int x)                )(int a,int b)
    
    // int (__cdecl*    (__cdecl*    __cdecl(void)           )(int)                   )(int,int)
    
    void main()
    {
        cout << typeid(pf).name() << endl;
    
        cin.get();
    }
    
    

    模板别名

    template<class T> using t = T;
    template<class T> using tp = T*;
    template<class T> 
    T show(T t1)
    {
        t<T> tx(t1);
        tp<T>tp1(&tx);
    
        cout << tx << "  " << tp1 << endl;
    
        return  tx;
    }
    
    #include<array>
    
    //模板别名 用别名优化模板名称 只能放在类 命名空间 全局 不能放在函数内部
    template<class T1> using t1 = array<T1,10>;
    
    template<class T, int n> using  wu = array<T, n>;
    
    void main01()
    {
        using intarry = array<int, 10>; //模板别名  明确类型
    
    
        double a=10;
    //  cout << show(a) << endl;
    
        t1<int> t11{ 1,2,3,4,5,6,7,8,9,10 };
        for each (auto i in t11)
        {
            cout << i << endl;
        }
    
        wu<int, 10> t12{ 1,2,3,4,5,6,7,8,9,10 };
        for each (auto j in t12)
        {
            cout << j << endl;
        }
    
        cin.get();
    }
    

    收缩转换 constexpr inline

    //收缩转换
    void main02()
    {
    
        //char ch0(7777) ; // 不保证结果的正确
        //char ch1{ 7777 };// 保证数据类型安全转换  越界编译错误
    
        cin.get();
    }
    
    //C++14 二进制
    void main03()
    {
        int a = 0b1001; //0b 0B代表二进制
        cout << a << endl; //9
        cin.get();
    }
    
    //constexpr 标识返回值或者其他表达式是常量
    constexpr int get()
    {
        return 5;
    }
    
    //inline
    namespace all
    {
        //inline 展开在all 默认的版本
        inline namespace V2015
        {
    
        }
    }
    

    lambda表达式

    初级

    //lambda表达式:  解决函数怀孕现在
    
    void main04()
    {
        //[] {cout << "ssssss" << endl;}();   //匿名表达式   ()最后一个括号 起调用
                                              //              { } 函数体 执行                                
    
        auto fun = [] {cout << "sssss" << endl;};   //返回函数指针
        fun();  //调用
    
        []{ cout << "xxxxxxx" << endl,cout << "ddddd" << endl; }();
    
          //[]操作外部变量  ()参数列表    {}函数体   ()调用
        [] (char*str){cout << str << endl;}("kkkkk");  //匿名
    
    
        auto fun1 = [](char*str) {cout << str << endl;};
        fun1("yyyyyy");       //lambda 不可以直接取地址  无法当作函数指针
    
    
        auto fun2 = [](double a,double b)->int {return a+b;};  //指定返回值类型为int     ->  在()和{}之间  指定返回类型
        //内联展开,无法取出地址
    
        //->decltype(a+b)  自动推理类型
        auto fun3 = [](double a, int b)->decltype(a+b){return a + b;};
        fun3(10, 11); //遵循副本机制
    
        cin.get();
    }
    
    

    高级

    #include<array>
    #include<algorithm> //算法头文件
    
    
    void main()
    {
    
        int num1 = 10;
        int num2 = 11;
        [=]() {cout << num1 << "  " <<num2<< endl;}();  //  = 只能读外部变量 不能写
        [&]() {num1 = 50, num2 = 64, cout << num1 << "  " << num2 << endl;}();   //&  读写外部变量
        [=]()mutable {num1 = 50, num2 = 64, cout << num1 << "  " << num2 << endl;}();  // = mutable  修改副本
    
    
    
        int a = 10, b = 20, c = 30;
        [&a, b, c]() {a = 111, cout << a << "  " << b << " " << c << endl;}();  //[&a, b, c]  仅a可读可写  bc只可读
                                                                                //[a,b,c] mutable   读原本 写副本      =只能指定全部
    
    
        //2015
        [](auto a = 0, auto b = 0) {cout << a + b << endl;}(10.8,11);   //C++14 推理数据类型   默认参数只能用=
    
    
        array<int, 10> myint{1,2,3,4,5,6,7,8,9,10};  //CPP风格叔祖
        for_each(myint.begin(), myint.end(), [](int num) {cout << num << endl;});  //显示
        for_each(myint.begin(), myint.end(), [&](int num) {num+=1,cout << num << endl;});  //修改
    
        cin.get();
    }
    

    函数包装器

    #include<functional>  //函数包装头文件
    using std::function;  //函数包装器
    
    void go()
    {
        cout << "go" << endl;
     
    }
    
    
    int add(int a, int b)
    {
        return a + b;
    }
    
    void main06x()
    {
               //返回值 参数
        function<void(void)>  fun1 = go;
        fun1();
    
        function<void(void)>  fun2 = []() {cout << "go  lambda" << endl;};
        fun2();
    
        function<int(int, int)> fun3 = add;
        fun3(10,19);
    
    
        cin.get();
    }
    

    模板元

    int get50(int n)
    {
        if (n==1)
        {
            return 1;
        }
        else if(n==2)
        {
            return 2;
        }
        else
        {
            return get50(n - 2) + get50(n - 2);
        }
    }
    
    //递归: 反复调用 函数等待 返回 浪费时间多
    //模板元实现递归加速
    //执行速度快 编译时候慢 代码体积会增加
    //模板元 只能处理常量 把代码的运行时间放在了编译的时间  C11
    
    template<int N>
    struct data
    {
        //递归
        enum {res=data<N-1>::res+data<N-2>::res};
    };
    
    template<>
    struct data<1>
    {
        enum {res=1};
    };
    
    template<>
    struct data<2>
    {
        enum { res = 2 };
    };
    
    void main()
    {
    
        cout << data<40>::res << endl;  //模板元 只能处理常量 把代码的运行时间放在了编译的时间
        cout << get50(50) << endl;
    
        cin.get();
    }
    

    const

    //C语言const 只能避免直接 无法避免间接
    
    
    //const 在*左边 内容不能改变   在*右边 地址不能改变
    
    void run1(const int *p);     //可以改变地址 不能改变内容
    void run2(int const *p);
    
    void run3(int* const  p);   //不可以改变地址 能改变内容
    
    void run4(const int *  const p); //bu可以改变地址 不能改变内容
    void run5(int const  * const p);
    
    void main0xx7()
    {
    
        const int n = 10;
        int a[n]{0};   //C++编译器自动优化  n替换为10
    
        const int num = 10;
        *(int*)(&num) = 3;
        cout << (void*)&num << endl;  
        cout << *(&num) << endl; // 10         读寄存器 自动优化  强行替换为10
    
        int a = 10;
        //const int num1 = a;
        *(int*)(&num1) = 3;
        cout << (void*)&num1 << endl;
        cout << *(&num1) << endl; // 3        直接读内存 不作优化
    
    
        const int numa[5]{ 1,2,3,4,5 };
        const int*p = numa;
        *(int*)p = 100;
        //const数组 没有优化 可以间接改变
        //*(p+2)=1;  指向常量的指针 无法修改
    
    
        cin.get();
    }
    

    智能指针

    //智能指针 内存泄漏 自动管理内存
    
    void autoptr()
    {
        while (1)
        {
            double *p(new double[1024 * 1024]);
            auto_ptr<double>autop(p);  //接管  自动回收
        }
    
    }
    
    void autoptnew()
    {
        while (1)
        {
            unique_ptr<double> p(new double[1024 * 1024*10]);  //
        }
    
    }
    

    tuple

    
    //多元数组  tuple  存取不同的数据类型
    #include<tuple>
    void main08x()
    {
    
        char ch = 'x';
        short sh = 1;
        int num = 22221;
        double db = 123.1;
        char*p = "calc";
    
        tuple<char, short, int, double, char*> mytule(ch,sh,num,db,p);
        auto autov = get<0>(mytule);  //<> 里面只能是常量
        cout << autov << endl;
    
    
        cin.get();
    }
    
    

    相关文章

      网友评论

          本文标题:2018-05-06

          本文链接:https://www.haomeiwen.com/subject/xvgprftx.html