#include <iostream>

 void f(int i)

 {

     std::cout << "i: " << i << std::endl;

     return;

 }

 void f(int *s)

 {

     std::cout << "s: " << s << std::endl;

     return;

 }

 int main(void)

 {

     //f(NULL);

     f(nullptr);

     return ;

 }

 #include <iostream>

 enum E0

 {

     Val1,

     Val2

 };

 enum E1

 {

     Val,

     Val1

 };

 int main(void)

 {

     return ;

 }

 #include <iostream>

 enum class E2 : bool

 {

     Val1,

     Val2,

 };

 enum class E3

 {

     Val,

     Val1

 };

 int main(void)

 {

     //bool k = E2::Val1; /* error */

     bool b = static_cast<bool>(E2::Val2);

     return ;

 }

int a = ;            /* 拥有自动生命期 */

auto int b =         /* 拥有自动生命期 */

static int c =       /* 延长生命期 */

 #include <iostream>

 #include <typeinfo>

 int main(void)

 {

     auto a = ;

     auto b = 20LL;

     auto c = "hello world";

     if (typeid(a) == typeid(int))

     {

         std::cout << "a is int" << std::endl;

     }

     if (typeid(b) == typeid(long long))

     {

         std::cout << "b is long long" << std::endl;

     }

     if (typeid(c) == typeid(const char *))

     {

         std::cout << "c is const char *" << std::endl;

     }

     return ;

 }

a is int

b is long long

c is const char *

 #include <string>

 #include <vector>

 int main(void)

 {

     /* 传统写法 */

     std::vector<std::string> vs1;

     for (std::vector<std::string>::iterator i = vs1.begin(); i != vs1.end(); i++)

     {

         /* ... */

     }

     /* 使用auto */

     std::vector<std::string> vs2;

     for (auto i = vs2.begin(); i != vs2.end(); i++)

     {

         /* ... */

     }

     /* 配合范围的遍历操作更加简洁 */

     std::vector<std::string> vs3;

     for (auto &i : vs3)

     {

         /* ... */

     }

     return ;

 }

#include <iostream>

template <typename _Tx,typename _Ty>

void Multiply(_Tx x, _Ty y)

{

    auto v = x * y;

    std::cout << v << std::endl;

}

int main(void)

{

    return ;

}

#include <iostream>

template <typename _Tx, typename _Ty>

auto multiply(_Tx x, _Ty y)->decltype(x * y)

{

    return x * y;

}

int main(void)

{

    return ;

}

 auto a1 = , a2 = , a3 = ;   /* 正确 */

 auto a4 = , a5 = 1.1, a6 = 'k'; /* 错误, 没有推到成为同一类型 */

 #include <iostream>

 int main(void)

 {

     int arr[] = {, , , , , , , };

     //for (const auto &val : arr)

     for (const int &val : arr)

     {

         std::cout << "val: " << val << std::endl;

     }

     return ;

 }

 #include <iostream>

 class A

 {

 public:

     A(int new_number) : m_nNumber(new_number) { std::cout << "hello world" << std::endl;    }

     A() : A() {   std::cout << "hello world 2" << std::endl;  }

 private:

     int m_nNumber;

     int m_nValue = ;

 };

 int main(void)

 {

     A a;

     return ;

 }

 #include <iostream>

 #include <vector>

 #include <map>

 #include <initializer_list>

 class A

 {

 public:

     A(std::initializer_list<int> items)

     : m_nNumber(*items.begin())

     {};

 private:

     int m_nNumber;

 };

 int main(void)

 {

     std::vector<int> vec1{, , , , , , , };

     std::vector<int> vec2 = {, , , , , , , };

     std::map<int, int> map1 = { {, }, {, }, {, }, {, } };

     A a1{, };

     A a2{, , , };

     return ;

 }

 constexpr int func1()

 {

     return ;

 }

 constexpr int func2(int val)

 {   /* 如果val是常量表达式, 则func2(val)也是常量表达式 */

     return val * func1();

 }

 int main(void)

 {

     constexpr int a = ;        /* 20 是常量表达式 */

     constexpr int b = a + ;     /* a + 2 是常量表达式 */

     constexpr int c = func2();

     //int i = 100;

     //constexpr int d = func2(i); /* i 不是常量表达式, 所以func2(i)不是常量表达式, 该语句error */

     return ;

 }

 class A

 {

 public:

     A() = default;

     A(const A &a) = delete;

 };

 int main(void)

 {

     A a;

     //A b(a); /* 拷贝构造函数已经声明为delete, 无法调用. */

     return ;

 }

 #include <iostream>

 class A

 {

 public:

     A() = default;

     virtual ~A() {  std::cout << "~A" << std::endl; }

     virtual void func1() {  std::cout << "A::func1" << std::endl;   }

     virtual void func2() final {    std::cout << "A::func2" << std::endl;   }

 };

 class Base final

 {

 public:

     Base() = default;

     ~Base() = default;

 };

 class B

 : public A

 //, public Base /* Base被final修饰, 不能再作为基类被继承 编译会失败*/

 {

 public:

     B() = default;

     virtual ~B() {  std::cout << "~B" << std::endl; }

     virtual void func1() override { std::cout << "B::func1" << std::endl;   }

     //virtual void func2() override {   std::cout << "B::func2" << std::endl;   } /* 基类已经禁止重载 编译会失败 */

     //virtual void func3() override {   std::cout << "B::func3" << std::endl;   } /* 基类没有该函数 编译会失败 */

 };

 int main(void)

 {

     int override = ;

     int final;

     final = ;

     std::cout << "override: " << override << std::endl;

     std::cout << "final: " << final << std::endl;

     A *a = new B();

     a->func1();

     delete a;

     a = nullptr;

     return ;

 }

 #include <type_traits>

 class A

 {

 public:

     A() {}

     virtual ~A() {}

 private:

 };

 class B

 : public A

 {

 public:

     B() {}

 };

 int main(void)

 {

     /* 若B空类类型(无异于0大小位域的非静态数据成员, 无虚函数, 无虚基类, 且无非空基类和非联合类类型), 则为true */

     static_assert(std::is_empty<B>::value, "error..."); /* 是否是空类 */

     /* 若B派生自A 或 为同一非联合类, 则为true */

     static_assert(std::is_base_of<A, B>::value, ".......error........");

     /* POD 类型为true */

     static_assert(std::is_pod<B>::value, ".......error........");

     /*

      * 是否是整数类型 bool 、 char 、 char8_t 、 char16_t 、 char32_t 、

      * wchar_t 、 short 、 int 、 long 、 long long 类型，或任何实现定义

      * 的扩展整数类型，包含任何有符号、无符号及 cv 限定的变体。则提供等

      * 于 true

      * */

     static_assert(std::is_integral<int>::value, ".......error........");

     /* ... ... */

     return ;

 }

 #include <iostream>

 unsigned long long operator"" _god(unsigned long long n)

 {

     return n * ;

 }

 int main(void)

 {

     auto n = 3_god;

     std::cout << "n: " << n << std::endl;

     return ;

 }

 #include <iostream>

 int main(void)

 {

     char16_t ch1;

     char32_t ch2;

     std::cout << u8"hello world" << std::endl;

     std::cout << u"hello world" << std::endl;

     std::cout << U"hello world" << std::endl;

     std::cout << R"("hello  world")" << std::endl;

     std::cout << u8R"(hello"" \   world)" << std::endl;

     return ;

 }

 #include <iostream>

 void f()

 {

     std::cout << "f()" << std::endl;

 }

 template <typename T, typename... Args>

 void f(T t, Args... args)

 {

     /* 打印可变参数的长度(参数的个数) */

     std::cout << "args: " << sizeof...(args) << std::endl;

     f(args...); /* 传入可变参数 */

     return;

 }

 int main(void)

 {

     f(, , , "he", "");

     return ;

 }

 #include <vector>

 int main(void)

 {

     std::vector<std::vector<int>> vec1;  /* c++11支持 */

     std::vector<std::vector<int> > vec2;

     return ;

 }

[capture list] (parameter list) mutable或exception声明 ->return type {function body};

 #include <iostream>

 int main(void)

 {

     int n = ;

     int m = ;

     auto f1 = [m]() mutable {   return ++m; };

     std::cout << "f1: " << f1() << std::endl;

     std::cout << "m: " << m << std::endl;

     auto f2 = [&n]() {  return ++n; };

     std::cout << "f2: " << f2() << std::endl;

     std::cout << "n: " << n << std::endl;

     auto f3 = [=](char x) mutable ->int {   m = x; return m;    };

     std::cout << "f3: " << f3('') << std::endl;

     std::cout << "m: " << m << std::endl;

     return ;

 }

 int main(void)

 {

     auto f4 = [](int x) {   return ;    };

     void (*func_ptr)(int) = f4;

     return 0;
7 }

 #include <utility>

 int main(void)

 {

     int a = ;

     int &b = a;

     //int &&c = a;          /* error 右值引用不能绑定到左值 */

     //int &d = a * 2;       /* erro   a * 2 是一个右值 */

     const int e = a * ;    /* const 的引用可以绑定到一个右值 */

     int && f = a * ;       /* 右值引用可以绑定到右值 */

     //int && g = f;         /* error 不能将一个右值引用绑定到一个变量上, 即使这个变量是右值引用类型也不行 */

     int && h = std::move(f); /* ok */

     return ;

 }

 int r1 = ;

 int &&r2 = std::move(r1);

 #include <stdio.h>

 #include <string.h>

 #include <iostream>

 #include <iterator>

 int main(void)

 {

      char s1[] = "hello world";

      const char *psbeg = std::begin(s1);

      char *psend = std::end(s1);

      printf("psbeg:\t%p\ns1:\t%p\n", psbeg, s1);

      /* end返回的是数组结尾的下一个地址 */

      printf("psend - 1:\t%p\ns1[strlen(s1)]:\t%p\n", psend - , &s1[strlen(s1)]);

     return ;

 }

 #include <vector>

 int main(void)

 {

     std::vector<int> vec;

     std::vector<int>::const_iterator it = vec.cbegin();

     return ;

 }

 #include <iostream>

 #include <array>

 int main(void)

 {

     std::array<int, > arr1 = {, };

     std::cout << sizeof(arr1) << std::endl;

     std::cout << arr1.size() << std::endl;

     std::cout << "arr[1]: " << arr1[] << std::endl;

     for (auto &val : arr1)

     {

         std::cout << "val: " << val << std::endl;

     }

     return ;

 }

 #include <iostream>

 #include <string>

 int main(void)

 {

     int a1 = ;

     std::string s1 = std::to_string(a1);

     a1 = std::stoi("", nullptr, );

     int a2 = std::stoi("");            /* 使用默认的p和b, 可以省略不写 */

     std::cout << "s1: " << s1 << std::endl;

     std::cout << "a1: " << a1 << std::endl;

     std::cout << "a2: " << a2 << std::endl;

     return ;

 }

 #include <iostream>

 #include <string>

 #include <regex>

 int main(void)

 {

     std::string str1[] = {"foo.txt", "b.txt", "abcd.txt", "txt", "a0.txt", "AAA.txt", "wt.txt"};

     std::regex txtRegex("[a-z]+\\.txt");

     std::regex baseRegex("([a-z]+)\\.txt");

     std::smatch baseMatch;

     for (const auto &s : str1)

     {

         if (std::regex_match(s, baseMatch, baseRegex))

         {

             std::cout << "baseMatch[0]: " << baseMatch[] << std::endl;

             std::cout << "baseMatch.szie: " << baseMatch.size() << std::endl;

             if (baseMatch.size() == )

             {

                 std::string str = baseMatch[].str();

                 std::string base = baseMatch[].str();

                 std::cout << "str: " << str << std::endl;

                 std::cout << s << " : " << base << std::endl;

             }

         }

     }

     return ;

 }

 #include <iostream>

 class Base

 {

 public:

     void func1() const noexcept {   return; }

     virtual void func2() {  return; }

     virtual void func3() noexcept = ;

     virtual void func4() noexcept final {   return; }

 };

 class Derive

 : public Base

 {

 public:

     virtual void func2() noexcept override {    return; }

     virtual void func3() noexcept override {    return; }

 };

 void f1() noexcept {    return; }

 void f2() { return; }

 int main(void)

 {

     std::cout << noexcept(f1()) << std::endl;

     std::cout << noexcept(f2()) << std::endl;

     Derive d;

     std::cout << noexcept(d.func2()) << std::endl;

     std::cout << noexcept() << std::endl;

     return ;

 }

 #include <string>

 class Base1

 {

 public:

     Base1() = default;

     Base1(const std::string&)   {};

 };

 class Base2

 {

 public:

     Base2() = default;

     Base2(const std::string&)  {};

 };

 class Derive

 : public Base1

 , public Base2

 {

 public:

     using Base1::Base1; /* 从Base1继承构造函数 */

     using Base2::Base2; /* 从Base2继承构造函数 */

     Derive() = default;

     /*

      * 因为从多个基类继承了相同的构造函数,

      * 如果不定义一个可以接受string的构造函数, 则会报错

      * */

     Derive(const std::string&s): Base1(s), Base2(s) {}

 };

 int main(void)

 {

     return ;

 }

 #include <memory>

 class Dealloc

 {

 public:

     Dealloc() = default;

     //括号()操作符的重载

     void operator() (int* p )

     {

         if (p != nullptr)

         {

             delete p;

             p = nullptr;

         }

     }

 };

 void shared_ptr_func(void)

 {

     //1. 创建

     std::shared_ptr<int> sp0; /* 空智能指针 */

     std::shared_ptr<int> sp1 = std::shared_ptr<int>(new int());

     std::shared_ptr<int> sp2 = std::make_shared<int>(int());

     //2. 自定义资源释放函数

     {

         auto sp4 = std::shared_ptr<int>(new int[], [](int *p){ delete[ ] p; });

     }

     {

         // 括号()操作符的重载

         auto sp5 = std::shared_ptr<int>(new int(), Dealloc() );

     }

     //3. 复制

     auto sp6(sp1);

     auto sp7 = sp1;

     //4. 获取保存的指针

     int* pRaw = sp2.get();

     //5. 返回共享对象的智能指针数量.

     long nCount1 = sp1.use_count();

     long nCount2 = sp2.use_count();

     //6. 是否是独享

     bool b1 = sp1.unique();

     bool b2 = sp2.unique();

     //7. swap

     sp1.swap(sp2);

     //8. reset 重置指向另一个对象, 原指针引用计数减一

     sp1.reset(new int());

 }

 void del(int *p) { delete p; }

 void unique_ptr_func(void)

 {

     std::unique_ptr<int> up0;

     std::unique_ptr<int> up1(new int());

     //std::unique_ptr<int> up2(up1); /* 不支持拷贝 */

     std::unique_ptr<int> up2(up1.release());

     up2.reset(up0.release());

     //up0 = up1; /* error 不支持赋值 */

     std::unique_ptr<int, decltype(del) *> up3(new int(), del);

 }

 void weak_ptr_func()

 {

     std::shared_ptr<int> sp0 = std::make_shared<int>(int());

     std::weak_ptr<int> wp0(sp0); /* 不会改变sp0的引用计数 */

     bool b1 = wp0.expired();

     std::shared_ptr<int> sp1 = wp0.lock();

     std::weak_ptr<int> wp1 = wp0.lock();

 }

 int main(void)

 {

     shared_ptr_func();

     unique_ptr_func();

     weak_ptr_func();

     return ;

 }