void Swap(int& left, int& right)
{
  int tmp = left;
  left = right;
  right = tmp;
}
void Swap(double& left, double& right)
{
  double tmp = left;
  left = right;
  right = tmp;
}

template<typename T>//typename和class这里都可以
void Swap(T& left, T& right)
{
  T tmp = left;
  left = right;
  right = tmp;
}
int main()
{
  int a = 1, b = 2;
  Swap(a, b);
  double c = 1.1, d = 2.2;
  Swap(c, d);
  return 0;
}

template<class T>
T Add(const T& left, const T& right)
{
  return left + right;
}
int main()
{
  int a1 = 10, a2 = 20;
  double d1 = 10.1, d2 = 20.2;
  //自动推演实例化，让编译器推导T的类型
  cout << Add(a1, a2) << endl;
  cout << Add(d1, d2) << endl;
  cout << Add((double)a1, d2) << endl;//强制类型转换，产生临时变量，临时变量具有常性
  cout << Add(a1, (int)d2) << endl;
  //显示实例化，直接告诉编译器T的类型
  cout << Add<double>(a1, d2) << endl;//隐式类型转换，产生临时变量，临时变量具有常性
  cout << Add<int>(a1, d2) << endl;
  return 0;
}

template<class T1,class T2>
T1 Add(const T1& left, const T2& right)
{
  return left + right;
}
int main()
{
  int a1 = 10, a2 = 20;
  double d1 = 10.1, d2 = 20.2;
  //自动推演实例化，让编译器推导T的类型
  cout << Add(a1, a2) << endl;//T1和T2都推成int
  cout << Add(d1, d2) << endl;//都推成double
  cout << Add(a1, d2) << endl;//推成一个是int，一个是double
  cout << Add(d1, a2) << endl;
  return 0;
}

// 专门处理int的加法函数
int Add(int left, int right)// _Z3Addii
{
  return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)// _Z3TAddii（修饰规则不一定这样，只是假设而已）
{
  return left + right;
}
//一个具体的函数和模板函数能不能同时存在呢？答案是可以的，他们是可以同时存在的
int main()
{
  int a = 1, b = 2;
  Add(a, b);//会优先调用具体的函数，而不是调用模板进行推导。编译器很勤快，但它不傻。
  Add<int>(a, b);//显示调用模板推导出来的函数。
  //上面两行代码可以说明模板推导的int函数和具体的int函数可以同时存在，那么就可以证明这两个函数的函数名修饰规则是不一样的
  return 0;
}

template<typename T>
class Stack
{
public:
  Stack(int capacity = 4)
  {
    cout << "Stack(int capacity = )" <<capacity<<endl;
    _a = (T*)malloc(sizeof(T)*capacity);
    if (_a == nullptr)
    {
      perror("malloc fail");
      exit(-1);
    }
    _top = 0;
    _capacity = capacity;
  }
  ~Stack()
  {
    cout << "~Stack()" << endl;
    free(_a);
    _a = nullptr;
    _top = _capacity = 0;
  }
  void Push(const T& x)//用引用效率高一点，因为类对象可能所占字节很大，如果不改变最好加const
  {
    // ....
    // 扩容
    _a[_top++] = x;
  }
private:
  T* _a;
  int _top;
  int _capacity;
};
int main()
{
  //Stack st1; 
  st1.push(1);
  //st1.Push(1.1);
  //Stack st2; 
  //st2.Push(1);
  //一个栈存int，一个栈存double这样的场景，用typedef无法解决，必须使用类模板来解决。
  //函数模板可以通过实参传递形参，推演模板参数。但是类模板一般没有推演的时机，统一使用显示实例化。
  Stack<int> st1;
  st1.Push(1);
  Stack<double>st2;
  st2.Push(1.1);
  //180和182行是两个不同的类类型，因为类的大小有可能不同，所以类模板相同，但模板参数不同，则类模板实例化出来的类是不同的。
  //st1 = st2;//这样的操作是不允许的，因为如果类不同，则实例化对象肯定也不相同，所以不可以赋值。
  return 0;
}

#define N 10
namespace wyn
{
  template<class T>
  class array
  {
  public:
    inline T& operator[](size_t i)//内联，不会建立栈帧，提高效率，减少性能损耗。
    {
      assert(i < N);//不依赖于抽查行为
      return _a[i];
    }
  private:
    T _a[N];
  };
}
int main()
{
  int a2[10];
  //C语言对于越界访问是抽查的方式，访问近一点的位置，会查到报错，但访问远一点的位置，就有可能不会报错。
  //a2[10] = 10;
  //a2[20] = 20;//对于越界访问写，勉强会检查到。
  a2[10];
  a2[20] ;//但对于越界访问读，基本不会检查出来。
  wyn::array<int> a1;//array有可能和std命名空间里面的array冲突，所以我们自己定义一个命名空间
  for (size_t i = 0; i < N; i++)
  {
    a1[i] = i;
    //等价于 a1.operator[](i)=i;
  }
  for (size_t i = 0; i < N; i++)
  {
    a1[i]++;
  }
  for (size_t i = 0; i < N; i++)
  {
    cout << a1[i] << " ";
  }
  cout << endl;
  return 0;
}

template<class T>
Stack<T>::Stack(int capacity)//声明处写了缺省值，定义处就不用写了。
{
  cout << "Stack(int capacity = )" << capacity << endl;
  _a = (T*)malloc(sizeof(T) * capacity);
  if (_a == nullptr)
  {
    perror("malloc fail");
    exit(-1);
  }
  _top = 0;
  _capacity = capacity;
}
template<class T>
Stack<T>::~Stack()
{
  cout << "~Stack()" << endl;
  free(_a);
  _a = nullptr;
  _top = _capacity = 0;
}
template<class T>
void Stack<T>::Push(const T& x)
{
  // ....
  // 
  _a[_top++] = x;
}