C++11常用的14个功能

// ThreadStudy.cpp : 定义控制台应用程序的入口点。
//
// C11 特性总结

#include "stdafx.h"
#include <iostream>  
#include <vector>
#include <list>
#include <map>
#include <string>
#include <memory>
//#include <functional>
#include <algorithm>
#include <assert.h>
#include <thread>
#include <regex>
#include <random>

void 性质1()
{
    // 类型自动推导
    auto i = 42;        // i is an int
    auto l = 42LL;      // l is an long long

    // 下面的就很方面了
    std::vector<int> vi;
    for (std::vector<int>::iterator ite = vi.begin(); ite != vi.end(); ++ite)
    {
    }
    for (auto ite = vi.begin(); ite != vi.end(); ++ite)
    {
    }
}

void 性质2()
{
    // 空指针有宏提升为关键字，带来了更加安全的编译检查
    int res = 0;
    int *p1 = nullptr;
    int *p2 = NULL;
    // 不能编译通过
    //int i1 = nullptr;
    //可以编译通过
    //int i2 = NULL;
}

void 性质3()
{
    // 原来繁琐的循环现在变得简单多了
    std::map<std::string, std::vector<int>> map;
    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);

    map["one"] = v;

    for (const auto & kvp : map)
    {
        std::cout << kvp.first << std::endl;
        for (auto v : kvp.second)
        {
            std::cout << v << std::endl;
        }
    }
    int arr[] = { 1, 2, 3, 4, 5 };
    for (auto& e : arr)
    {
        e = e * e;
    }
}


void 性质4()
{
    // 让不明确的重载变的明确
    // 这个经常变成考试程序员的一个头疼题目
    // 现在做了更加严格的检查，声明想重载，和不想重载
    {
        class A
        {
        public:
            virtual void f(short) { std::cout << "A::f" << std::endl; }
        };

        class B : public A
        {
        public:
            virtual void f(int) { std::cout << "B::f" << std::endl; }
        };

        //  输出的竟然是A
        A  *p = new B();
        p->f(1);
    }
    {
        class A
        {
        public:
            virtual void f(int) const { std::cout << "A::f " << std::endl; }
        };
        class B : public A
        {
        public:
            virtual void f(int) { std::cout << "B::f" << std::endl; }
        };

        A  *p = new B();
        p->f(1);
    }
    // 上面的两个竟然输出了A
    {
        class A
        {
        public:
            virtual void f(short) { std::cout << "A::f" << std::endl; }
            // 不应当重载这个虚函数
            virtual void g(int) final { std::cout << "A::g" << std::endl; }
        };
        class B : public A
        {
        public:
            // 声明要重载，如果没有重载成功报编译错误
            virtual void f(short) override { std::cout << "B::f" << std::endl; }
            // 如果重载将会报错
            //virtual void g(int) { std::cout << "A::g" << std::endl; } // error C3248: “main::A::g”:  声明为“final”的函数无法被“main::B::g”重写
            // 确实没有重载
            virtual void g(float) { std::cout << "A::g" << std::endl; } // 重载
        };
    }
}

void 性质5()
{
    //强类型枚举 可以编译通过
    enum class N1 { None, One, All };
    enum class N2 { None, One, All };
    // 传统的方法出现重定义
    /*
    enum  A1
    {
    None, One, All
    };
    enum  A2
    {
    None, One, All
    };*/
}

void 性质6()
{
    // unique_ptr 不能赋值给另外一个对象（没有拷贝构造函数），要真想这么做就用move吧
    // 如果就有一个指针指向一个对象就用unique_ptr，如果是多个指针指向一个对象就用shared_ptr（这个类使用了引用计数）
    // weak_ptr:shared_ptr的助手。 看这个名字都注定是个助手,想对对象进行观察，并且尽可能的降低海森堡效应

    // 智能指针数组的用法
    std::shared_ptr<std::vector<int>> pvi = std::make_shared<std::vector<int>>();
    std::vector<std::shared_ptr<int>> vpi;
    vpi.push_back(std::make_shared<int>(1));

    std::unique_ptr<int> px1 = std::make_unique<int>(10);
    //下面这句话将会引起编译错误
    //std::unique_ptr<int> px2 = px1;

    auto sp = std::make_shared<int>(10);

    assert(sp.use_count() == 1);
    std::weak_ptr<int> wp(sp);
    assert(wp.use_count() == 1);
    if (!wp.expired())
    {
        std::shared_ptr<int> sp2 = wp.lock();
        *sp2 = 100;
        assert(wp.use_count() == 2);
    }
    assert(wp.use_count() == 1);
}

void 性质7()
{
    // 如果是条件变量函数指针中使用了匿名函数，当唤醒的时候参数变量的值依然是睡眠时候的值（即便是值已经发生改变）
    // 这样可以用指针来代替
    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    std::for_each(std::begin(v), std::end(v), [](int n) {std::cout << n << std::endl; });
    auto is_odd = [](int n) {return n % 2 == 1; };
    auto pos = std::find_if(std::begin(v), std::end(v), is_odd);
    if (pos != std::end(v))
    {
        std::cout << *pos << std::endl;
    }
}

void 性质8()
{
    // 非成员begin()和end()
    // 来个例子吧，这个没什么好说的
    int arr[] = { 1, 2, 3 };
    std::for_each(std::begin(arr), std::end(arr), [](int n) {std::cout << n << std::endl; });
    auto is_odd = [](int n) {return n % 2 == 1; };
    auto pos = std::find_if(std::begin(arr), std::end(arr), is_odd);
    if (pos != std::end(arr))
        std::cout << *pos << std::endl;
}

template <typename T, size_t Size>
class Vector
{
    static_assert(Size > 3, "Size is too small");
    T _points[Size];
};

template <typename T1, typename T2>
T1 add(T1 t1, T2 t2)
{
    static_assert(std::is_integral<T1>::value, "Type T1 must be integral");
    static_assert(std::is_integral<T2>::value, "Type T2 must be integral");
    return t1 + t2;
}

void 性质9()
{
    // static_assert和 type traits
    // 这两个主要是用于编译时的(也主要用于高手之人)，就贴上两个例子吧
    // 1
    Vector<int, 11> a1;
    //Vector<double, 2> a2;

    std::cout << add(1, 3) << std::endl;
    //std::cout << add(1.1, 2) << std::endl;
}

void 性质10()
{
    // Move语义 仔细看下面的这篇博文吧，里面说的很清楚了
    class A
    {
    public:
        A()
        {
            printf("A() \n");
        }
        ~A()
        {
            printf("~A() \n");
        }
        // 这个函数代价高，需要复制对象
        A(const A& other)
        {
            printf("A(const A& other) \n");
        }

        // 这个函数代价低，仅仅是交换对象
        A(A&& other)
        {
            printf("A(A&& other) \n");
        }
    };

    std::list<A> va;
    A a;
    // 左值自动调用A(const A& other)
    va.push_back(a);
    // 通过语意转移调用A(A&& other)，a这个对象以后也就废掉了不能正常使用了，后面的风险有程序员负责
    va.push_back(std::move(a));
    //编译器知道是右值，因此自动调用A(A&& other)，临时对象也就自动消失了，没有上面一行代码的风险
    //交换回来的临时对象也需要析构
    va.push_back(A());
}

void f()
{
}

void 性质11()
{
    // 线程库，线程库还包含锁，条件变量，原子操作等一系列的功能
    std::thread t(f);
    t.join();
}

void 性质12()
{
    // 正则表达式
    using namespace std;
    cmatch match;
    if (regex_search("AAAAAAAAABBBBBBBBC", match, regex("^A*B+C?$")))
    {
        for (auto obj : match)
        {
            cout << obj << endl;
        }
    }
    else
    {
        cout << "No Match Case !" << endl;
    }
}

void 性质13()
{
    // 时间库
    using namespace std;
    using namespace chrono;
    auto begin = std::chrono::system_clock::now();
    this_thread::sleep_for(seconds(3));
    auto end = system_clock::now();

    auto duration = duration_cast<microseconds>(end - begin);
    cout << "花费了" << (duration.count() * microseconds::period::num) / microseconds::period::den << "秒" << endl;
}

void 性质14()
{
    // 随机数生成库, 还包括正态分布，均匀分布生成
    std::random_device rd;
    for (int n = 0; n < 200; ++n)
        std::cout << rd() << std::endl;
}