struct Point
{
  int _x;
  int _y;
};
int main()
{
  int x1 = 1;
  int x2{ 2 };
  int array1[]{ 1, 2, 3, 4, 5 };
  int array2[5]{ 0 };
  Point p{ 1, 2 };
  // C++11中列表初始化也可以适用于new表达式中
  int* pa = new int[4]{ 0 };
  return 0;
}

namespace tyj {
  template <class T>
  class vector {
    typedef T* iterator;
    typedef const T* const_iterator;
  public:
    //如何进行一个初始化, 范围形式的初始化
    vector(initializer_list<T>& l) {
      _start = new T[l.size()];
      _finish = _start + l.size();
      _endofstorage = _start + l.size();
      iterator sit = _start;
      //然后就是范围形式的构造了
      //如下是方式1： 基于范围的实现
      /*for (auto& e : l) {
        *sit++ = e;
      }*/
      //然后是第二种形式, 使用迭代器进行赋值, 其实也就是上述范围的赋值的底层
      typename initializer_list<T>::iterator lit = l.begin();
      while (lit != l.end()) {
        *sit++ = *lit++;
      }
    }
    //针对这个 operator = 赋值运算符的重载 还是复用上述的构造函数
    vector<T>& operator=(initializer_list<T> l) {
      vector<T> tmp(l);
      std::swap(_start, tmp._start);
      std::swap(_finish, tmp._finish);
      std::swap(_endofstorage, tmp._endofstorage);
      return *this;
    }
  private:
    iterator _start;
    iterator _finish;
    iterator _endofstorage;
  };
}
int main() {
  //测试上述的东西:
  //断点测试, 进去查看其中的内存即可
  tyj::vector<int> intv = initializer_list<int>{ 1, 2, 3, 4, 5 };
  return 0;
}

int main()
{
  int i = 10;
  auto p = &i;
  auto pf = strcpy;
  map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
  //map<string, string>::iterator it = dict.begin();
  auto it = dict.begin();
  return 0;
}

template<class T, class U> 
auto Add(T&& t, U&& u) 
    ->decltype(std::forward<T>(t) +std::forward<T>(u)) {
  return std::forward<T>(t) +std::forward<T>(u);
}
int main() {
  auto func = [](int a, double b)->decltype(a + b){ return a + b; };
  cout << Add(2, 5);
  while (1);
  return 0;
}

int main()
{
  double x = 1.1, y = 2.2;
  int&& rr1 = 10;
  const double&& rr2 = x + y;
  rr1 = 20;
  rr2 = 5.5;  // 报错
  return 0;
}

void swap(string& s) {
  ::swap(_str, s._str);
  ::swap(_size, s._size);
  ::swap(_capacity, s._capacity);
}   //提供swap方法方便转移资源
string(string&& s) 
  :_str(nullptr)
  ,_size(0)
  ,_capacity(0) {   
  swap(s);    //直接通过交换, 转移财产, 我的全是空, 和你换
    //反正你即将死亡, 不如将你的资源换给我助我快速构造加以利用
  std::cout << "string(string&& s) ---移动构造" << std::endl;
}
string& operator= (string&& s) {
    swap(s);
    std::cout << "string& operator= (string&& s) ---移动赋值" << std::endl;
    return *this;
}
tyj::string to_string(int val) {
  tyj::string s;    
  bool flag = 0;
  if (val < 0) {
    val *= -1;
    flag = 1;
  }
  while (val) {
    s.push_back(val % 10);
    val /= 10;
  }
  if (flag) s.push_back('-');
  std::reverse(s.begin(), s.end());
  return s;     // 返回即将消亡的局部对象, 如何优化掉这个深拷贝?
}

void PerfectForward(T&& t) {
  //先尝试一下不是完美转发
  //f(t);
  //然后进行完美转发
  f(std::forward<T>(t));  //转发之后效果就恢复正常了
}

template<class T>
struct ListNode
{
  ListNode* _next = nullptr;
  ListNode* _prev = nullptr;
  T _data;
};
//如下是实际的测试案例
template<class T>
class List
{
  typedef ListNode<T> Node; 
public:
  List()
  {
    _head = new Node;     //搞一个虚拟头部
    _head->_next = _head;
    _head->_prev = _head;   //双向循环
  }
  void PushBack(T&& x)
  {
    //Insert(_head, x);
    Insert(_head, std::forward<T>(x));  //完美转发
  }
  void PushFront(T&& x)
  {
    //Insert(_head->_next, x);
    Insert(_head->_next, std::forward<T>(x));
  }
  void Insert(Node* pos, T&& x)
  {
    Node* prev = pos->_prev;
    Node* newnode = new Node;
    newnode->_data = std::forward<T>(x); // 关键位置
    // prev newnode pos
    prev->_next = newnode;
    newnode->_prev = prev;
    newnode->_next = pos;
    pos->_prev = newnode;
  }
  void Insert(Node* pos, const T& x)
  {
    Node* prev = pos->_prev;
    Node* newnode = new Node;
    newnode->_data = x; // 关键位置
    // prev newnode pos
    prev->_next = newnode;
    newnode->_prev = prev;
    newnode->_next = pos;
    pos->_prev = newnode;
  }
private:
  Node* _head;
};
int main()
{
  List<tyj::string> lt;
  lt.PushBack("1111");
  lt.PushFront("2222");
  while (1);
  return 0;
}
//上述所有的 传入 && 右值引用作为参数的地方后序进一步传参全部需要使用forward<>()完美转发
//完美转发保持之前原有的类型属性不变, 如果不使用完美转发效果就是后序全部变成左值引用退化了
//可以取地址的就是左值了, 不可以取地址的才是右值, 右值一旦被变量接收其实也就退化成左值了
//如果想要继续保持右值的属性就需要完美转发

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

int main()
{
  // 下面我们试一下带有拷贝构造和移动构造的tyj::string，来试试
  // 我们会发现其实差别也不到，emplace_back是直接构造了，push_back
  // 是先构造，再移动构造，其实效率也还好, 差别不算很大
  std::list< std::pair<int, tyj::string> > mylist;
  mylist.emplace_back(10, "sort");
  mylist.emplace_back(make_pair(20, "sort"));
  mylist.push_back(make_pair(30, "sort"));
  mylist.push_back({ 40, "sort" });
  return 0;
}