从C语言到C++_33(C++11_上)initializer_list+右值引用+完美转发+移动构造/赋值（下）

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
 
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
 
// 万能引用(引用折叠)：t既能引用左值，也能引用右值
template<typename T>
void PerfectForward(T&& t)
{
  Fun(t); // 此时t变成了左值/const左值
}
 
int main()
{
  PerfectForward(10);           // 右值
 
  int a;
  PerfectForward(a);            // 左值
  PerfectForward(std::move(a)); // 右值
 
  const int b = 8;
  PerfectForward(b);          // const 左值
  PerfectForward(std::move(b)); // const 右值
 
  return 0;
}

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
 
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
 
 
// 万能引用(引用折叠)：t既能引用左值，也能引用右值
template<typename T>
void PerfectForward(T&& t)
{
  Fun(std::forward<T>(t)); // 完美转发：保持t引用对象属性
}
 
int main()
{
  PerfectForward(10);           // 右值
 
  int a;
  PerfectForward(a);            // 左值
  PerfectForward(std::move(a)); // 右值
 
  const int b = 8;
  PerfectForward(b);          // const 左值
  PerfectForward(std::move(b)); // const 右值
 
  return 0;
}

namespace rtx
{
  class string
  {
  public:
    string(const char* str = "")
      :_size(strlen(str))
      , _capacity(_size)
    {
      _str = new char[_capacity + 1];
      strcpy(_str, str);
    }
 
    void swap(string& s)
    {
      ::swap(_str, s._str);
      ::swap(_size, s._size);
      ::swap(_capacity, s._capacity);
    }
 
    string(const string& s) // 拷贝构造
      :_str(nullptr)
      , _size(0)
      , _capacity(0)
    {
      cout << "string(const string& s) -- 拷贝构造(深拷贝)" << endl;
      string tmp(s._str);
      swap(tmp);
    }
 
    string(string&& s) // 移动构造
      :_str(nullptr)
      , _size(0)
      , _capacity(0)
    {
      cout << "string(string&& s) -- 移动构造(资源转移)" << endl;
      swap(s);
    }
 
    string& operator=(const string& s) // 拷贝赋值
    {
      cout << "string& operator=(string s) -- 拷贝赋值(深拷贝)" << endl;
      string tmp(s);
      swap(tmp);
 
      return *this;
    }
 
    string& operator=(string&& s) // 移动赋值
    {
      cout << "string& operator=(string s) -- 移动赋值(资源移动)" << endl;
      swap(s);
 
      return *this;
    }
 
    ~string()
    {
      delete[] _str;
      _str = nullptr;
    }
 
  protected:
    char* _str;
    size_t _size;
    size_t _capacity;
  };
}
 
class Person
{
public:
  //Person(const char* name = "", int age = 0)
  //  :_name(name)
  //  , _age(age)
  //{}
  //Person(const Person& p) // 拷贝构造
  //  :_name(p._name)
  //  , _age(p._age)
  //{}
  //Person& operator=(const Person& p) // 拷贝赋值
  //{
  //  if (this != &p)
  //  {
  //    _name = p._name;
  //    _age = p._age;
  //  }
  //  return *this;
  //}
  //~Person()
  //{}
 
protected:
  rtx::string _name;
  int _age;
};
 
int main()
{
  Person s1;
  Person s2 = s1;
  Person s3 = std::move(s1);
  Person s4;
  s4 = std::move(s2);
  return 0;
}

// 要求delete关键字实现，一个类，只能在堆上创建对象
class HeapOnly
{
public:
    HeapOnly()
    {
        _str = new char[10];
    }
 
    ~HeapOnly() = delete;
 
    //void Destroy() // 如果要销毁只能这样
    //{
    //    delete[] _str;
 
    //    operator delete(this);
    //}
 
private:
    char* _str;
    //...
};