1
// 注意得是c语言中这么写，C++不可以这么写
2
int  *pi = NULL;
3
char *pc = NULL;

1
#include <iostream>
2
using namespace std;
3

4
void func(void* i)
5
{
6
  cout << "调用了参数为void*类型的函数" << endl;
7
}
8

9
void func(int i)
10
{
11
  cout << "调用了参数为int类型的函数" << endl;
12
}
13

14
void main(int argc,char* argv[])
15
{
16
  func(NULL);
17
  func(nullptr);
18
}
19
// 结果为
20
// 调用了参数为int类型的函数
21
// 调用了参数为void*类型的函数

1
auto temp = 2;

1
int x = 0;
2
auto *a = &x;  //a->int*，auto被推导为int
3
auto b = &x;  //b->int*，auto被推导为int*
4
auto &c = x;  //c->int&，auto被推导为int
5
const auto d = x;  //d->const int，auto被推导为int
6
auto e = c;  //e->int，auto被推导为int,丢弃引用
7
auto f = d;  //f->int，auto被推导为int,丢弃const
8
const auto& g = x;  //g->const int&，auto被推导为int
9
auto& h = g;  //h->const int&，auto被推导为const int,保留const
10
auto i = g;  //i->int，auto被推导为int,丢弃引用、丢弃const

1
double divisionMethod(int a, int b) noexcept
2
{
3
    if (b == 0)
4
    {
5
        cout << "division by zero!!!" << endl;
6
        return -1;
7
    }
8
    return a / b;
9
}

1
double divisionMethod(int a, int b) noexcept(常量表达式);
2

3
void fun(int a)noexcept(0)//值为 false，表示有可能抛出异常这里
4
{
5
  if (a == 0) throw("抛出异常");
6
}
7

8
void fun1(int a)noexcept("0")//值为 true，表示函数不会抛出异常
9
{
10
  if (a == 0) throw("抛出异常");
11
}

1
int main()
2
  {
3
    //如果我们的环境是32位平台那么在编译阶段就会提示我们自己定义的错误 no 32
4
    static_assert(sizeof(int*) == 4, "no 32 "); // 正确的
5
    static_assert(sizeof(int*) == 8, "no 64");//报错 no64
6

7
      //错误，a是变量，表达式要求是常量表达式
8
      int a = 4;
9
    static_assert(a == 4, "no 32 ");
10
    return 0;
11
  }

1
// 创建一个指定大小的 char 类型数组
2
char* createArray(int size)
3
{
4
  // 通过断言判断数组大小是否大于0
5
  assert(size > 0);  // 必须大于0, 否则程序中断
6
  char* array = new char[size];
7
  return array;
8
}
9

10
int main()
11
{
12
  char* buf = createArray(0);
13
  return 0;
14
}

1
[ capture ]( params )  -> ret {body;};

1
auto fun = [](){return 0;};
2
auto fun = []{return 0;};

1
int main()
2
{
3
  int a = 10, b = 20;
4
  auto f1 = [] {return a; };               // 错误，没有捕获外部变量，因此无法访问变量 a
5
  auto f2 = [&] {return a++; };         // 正确，使用引用的方式捕获外部变量，可读写
6
  auto f3 = [=] {return a; };              // 正确，使用值拷贝的方式捕获外部变量，可读
7
  auto f4 = [=] {return a++; };          // 错误，使用值拷贝的方式捕获外部变量，可读不能写
8
  auto f5 = [a] {return a + b; };          // 错误，使用拷贝的方式捕获了外部变量 a，没有捕获外部变量 b，因此无法访问变量 b
9
  auto f6 = [a, &b] {return a + (b++); };  // 正确，使用拷贝的方式捕获了外部变量 a，只读，使用引用的方式捕获外部变量 b，可读写
10
  auto f7 = [=, &b] {return a + (b++); };  // 正确，使用值拷贝的方式捕获所有外部变量以及 b 的引用，b 可读写，其他只读
11
  return 0;
12
}

1
class Test
2
{
3
public:
4
    void output(int x, int y)
5
    {
6
   auto x1 = [] {return m_number; };                 // 错误，没有捕获外部变量，不能使用类成员 m_number
7
   auto x2 = [=] {return m_number + x + y; };   // 正确，以值拷贝的方式捕获所有外部变量
8
  auto x3 = [&] {return m_number + x + y; };   // 正确，以引用的方式捕获所有外部变量
9
  auto x4 = [this] {return m_number; };            // 正确，捕获 this 指针，可访问对象内部成员
10
  auto x5 = [this] {return m_number + x + y; };   // 错误，捕获 this 指针，可访问类内部成员，没有捕获到变量 x，y，因此不能访问。
11
  auto x6 = [this, x, y] {return m_number + x + y; };    // 正确，捕获 this 指针，x，y
12
  auto x7 = [this] {return m_number++; };            // 正确，捕获 this 指针，并且可以修改对象内部变量的值
13
  }
14
    int m_number = 100;
15
};

1
  // 可以自动推导出返回值类型
2
  auto f = [](int i)
3
  {
4
    return i;
5
  }
6

7
  // 不能推导出返回值类型
8
  auto f1 = []()
9
  {
10
    return { 1, 2 };  // 基于列表初始化推导返回值，错误
11
  }
12

13
  // 正确显示声明了函数的返回值类型
14
    auto f1 = []()-> vector<int>
15
  {
16
    return { 1, 2 };  // 基于列表初始化推导返回值，错误
17
  };

1
class Base
2
{
3
public:
4
  virtual void test()
5
  {
6
    cout << "Base class...";
7
  }
8
};
9

10
class Child : public Base
11
{
12
public:
13
  void test() final
14
  {
15
    cout << "Child class...";
16
  }
17
};
18

19
class GrandChild : public Child
20
{
21
public:
22
  // 语法错误, 不允许重写
23
  void test()
24
  {
25
    cout << "GrandChild class...";
26
  }
27
};

1
class Base
2
{
3
public:
4
  virtual void test()
5
  {
6
    cout << "Base class...";
7
  }
8
};
9

10
class Child final : public Base
11
{
12
public:
13
  void test()
14
  {
15
    cout << "Child class...";
16
  }
17
};
18

19
//  语法错误
20
class GrandChild : public Child
21
{
22
public:
23
};

1
class Base
2
{
3
public:
4
  virtual void test()
5
  {
6
    cout << "Base class...";
7
  }
8
};
9

10
class Child : public Base
11
{
12
public:
13
        //正确，重写了父类的虚函数
14
  void test() override
15
  {
16
    cout << "Child class...";
17
  }
18
};
19

20
class GrandChild : public Child
21
{
22
public:
23
  //报错，父类中没有相同的虚函数可以被重写
24
  void test(int a) override
25
  {
26
    cout << "Child class...";
27
  }
28
};

1
class Base
2
{
3
public:
4
        //指定无参构造为默认函数
5
  Base() = default;
6

7
      //指定拷贝构造函数为默认函数
8
  Base(const Base& obj) = default;
9

10
        //指定移动构造函数为默认函数
11
  Base(Base&& obj) = default;
12

13
        //指定复制赋值操作符重载函数为默认函数
14
  Base& operator= (const Base& obj) = default;
15

16
        //指定移动赋值操作符重载函数为默认函数
17
  Base& operator= (Base&& obj) = default;
18

19
        //指定析构函数为默认函数
20
  ~Base() = default;
21
};

1
// 类定义
2
class Base
3
{
4
public:
5
  Base();
6
  Base(const Base& obj);
7
  Base(Base&& obj);
8
  Base& operator= (const Base& obj);
9
  Base& operator= (Base&& obj);
10
  ~Base();
11
};
12
// 在类定义之外指定成员函数为默认函数
13
Base::Base() = default;
14
Base::Base(const Base& obj) = default;
15
Base::Base(Base&& obj) = default;
16
Base& Base::operator= (const Base& obj) = default;
17
Base& Base::operator= (Base&& obj) = default;
18
Base::~Base() = default;

1
class Base
2
{
3
public:
4
  Base() = default;
5
  Base(const Base& obj) = default;
6
  Base(Base&& obj) = default;
7
  Base& operator= (const Base& obj) = default;
8
  Base& operator= (Base&& obj) = default;
9
  ~Base() = default;
10

11
  // 以下写法全部都是错误的
12
  Base(int a = 0) = default;    //自定义带参构造，不允许使用 =default 修饰（即使有默认参数也不行）
13
  Base(int a, int b) = default;  //自定义带参构造，不允许使用 =default 修饰
14
  void print() = default;           //自定义函数，不允许使用 =default 修饰
15
        //下面两行不是移动、复制赋值运算符重载，不允许使用 =default 修饰
16
  bool operator== (const Base& obj) = default;
17
  bool operator>=(const Base& obj) = default;
18
};

1
class Base
2
{
3
public:
4
  Base() = default;
5
  Base(const Base& obj) = delete;    //禁用拷贝构造函数
6
  Base& operator= (const Base& obj) = delete;   //禁用 = 进行对象复制/
7
};
8

9
int main()
10
{
11
  Base b;
12
  Base tmp1(b);    // 报错  拷贝构造函数已被显示删除，无法拷贝对象
13
  Base tmp = b;    // 报错
14
  return 0;
15
}

1
class Base
2
{
3
public:
4
  Base(int num) : m_num(num) {}
5
  Base(char c) = delete;    //禁用带 char 类型参数的构造函数，防止隐式类型转换（char 转 int)
6

7
  void print(char c) = delete;  //禁止使用带 char 类型的自定义函数，防止隐式类型转换（char 转 int)
8

9
  void print()
10
  {
11
    cout << "num: " << m_num << endl;
12
  }
13
  void print(int num)
14
  {
15
    cout << "num: " << num << endl;
16
  }
17
private:
18
  int m_num;
19
};
20

21
int main()
22
{
23
  Base b(97);
24
  Base b1('a');     // 'a' 对应的 acscii 值为97 报错 对应的构造函数被禁用，因此无法使用该构造函数构造对象
25
  b.print();
26
  b.print(97);
27
  b.print('a');     // 报错 对应的打印函数被禁用，因此无法给函数传递 char 类型参数
28
  return 0;
29
}

1
class Test
2
{
3

4
public:
5
  int min;
6
  int mid;
7
  int max;
8
  Test(int min)
9
  {
10
    this->min = min;
11
  }
12

13
  Test(int min, int max):Test(min)
14
  {
15
    this->max = max;
16
  }
17

18
  Test(int min, int mid, int max):Test(min,max)
19
  {
20
    this->mid = mid;
21
  }
22

23
};
24

25
int main()
26
{
27
  Test t(1,2,3);
28
  cout << t.min << " " << t.mid << "  " << t.max << endl;
29
  return 0;
30
}

1
#include <iostream>
2
using namespace std;
3

4
class father
5
{
6
  int min;
7
  int mid;
8
  int max;
9
public:
10
  father(int i) :min(i) {}
11
  father(int i, int j) :min(i), mid(j) {}
12
  father(int i, int j, int k) :min(i), mid(j), max(k) {}
13
};
14

15
class Child : public father
16
{
17
public:
18
  Child(int i):father(i){  }
19

20
  Child(int i, int j, int k) :father(i, j, k) {}
21
};
22

23
int main()
24
{
25
  Child c(1,2,3);
26
  return 0;
27
}

1
class T
2
{
3
private:   //基类构造函数声明为private
4
   T() = default;
5
   T(const int &a){}
6
   T(const int &a, float &b){}
7
};
8

9
class U : public T{
10
public:
11
    using T::T;  //报错
12

13
    int m_b{1};
14
};

1
int&& value = 520; // 右值引用，520是字面量，是右值
2

3
class Test
4
{
5
public:
6
  Test()
7
  {
8
    cout << "构造函数" << endl;
9
  }
10
  Test(const Test& a)
11
  {
12
    cout << "拷贝构造函数" << endl;
13
  }
14
};
15

16
Test getObj()
17
{
18
  return Test();
19
}
20

21
int main()
22
{
23
  int a1;
24
  //int &&a2 = a1;        // 报错 右值引用不能被左值初始化
25
  //Test& t1 = getObj();   // 右值不能初始化左值引用
26
  Test && t2 = getObj(); //函数返回的临时对象是右值，可以被引用
27
  const Test& t3 = getObj();// 常量左值引用是万能可以接收左值，右值，常量左值，常量右值
28
  const int& t3 = a1; //被左值初始化
29
  return 0;
30
}

1
#include<iostream>
2
using namespace std;
3
class Test
4
{
5
public:
6
  int a = 3;
7
  int* m_num = &a;
8
  Test() : m_num(new int(100))
9
  {
10
    cout << "构造函数" << endl;
11
  }
12

13
  Test(const Test& other) : m_num(new int(*other.m_num))
14
  {
15
    cout << "拷贝构造函数" << endl;
16
  }
17

18
  // 添加移动构造函数
19
  Test(Test&& a) : m_num(a.m_num)
20
  {
21
    a.m_num = nullptr;
22
    cout << "移动构造函数" << endl;
23
  }
24

25
  ~Test()
26
  {
27
    delete m_num;
28
    cout << "析构函数" << endl;
29
  }
30

31
};
32
Test getObj()
33
{
34
  Test t;
35
  return t;
36
}
37
int main()
38
{
39
  Test t = getObj();
40
  Test t2 = move(t); //此处调用移动构造，因为move返回一个右值
41
  return 0;
42
};

1
template<typename T>
2
void fun(T&& param)
3
{
4
    work（forward<T>（param））
5
}
6
int main()
7
{
8
  fun(10); //对于 f(10) 来说传入的实参 10 是右值，因此 T&& 表示右值引用
9
  int x = 1;
10
  fun(x);//对于 f(x) 来说传入的实参是 x 是左值，因此 T&& 表示左值引用
11
  return 0;
12
}

1
int main()
2
{
3
  int&& a1 = 1;       //右值推导为               右值引用
4
  auto&& bb = a1; //右值引用推导为       左值引用
5
  auto&& bb1 = 2; //右值推导为              右值引用
6

7
  int a2 = 1;
8
  int &a3 = a2;        //左值推导为                      左值引用
9
  auto&& cc = a3;    //左值引用推导为               左值引用
10
  auto&& cc1 = a2; //左值推导为                       左值引用
11

12
  const int& s1 = 1; // 常量左值引用
13
  const int&& s2 = 1;// 常量右值引用
14
  auto&& dd = s1;    // 常量左值引用推导为              左值引用
15
  auto&& ee = s2;   // 常量右值引用推导为               左值引用
16
  return 0;
17
}