一、函数重载与默认参数

1. 函数重载与自动类型转换 Overloading & Auto-Casting

   void print(int i);
   void print(double i);
   
   print('a');      // 调用 void print(int i)，发生自动类型转换
   print(3L);       // 3L 是 long 型，既可以转换为 int，也可以转换为 double，因此出现冲突，编译报错
   
   

2. 函数的默认参数 Default Arguments

   • 默认参数必须从参数表的最右侧开始提供
   • 默认参数的插入由编译器完成

   int harpo(int n, int m = 4,int j = 5);    // 合法
   int harpo(int n, int m = 4,int j);        // 不合法
   
   beeps = harpo(2);    // 等同于 harpo(2, 4, 5)
   

二、模版的概念

1. 要义：在类或函数的定义中，使用类别（Type）作为参数
2. 分类
   • 函数模版（Function Template）：例如 sort 函数
   • 类模版（Class Template）：例如 stack、list、queue 等容器

三、函数模版

1. 函数模版的定义

1. 使用 template 关键字定义模版类

   template <class T>
   void swap(T& x, T& y)
   {
   	T temp = x;
   	x = y;
   	y = temp;
   }
   
   template <class T>
   void sort(Vector<T>& arr);
   

2. class T 指定了一个参数化的类型名，该类型名可在以下场合使用：

   • 函数参数的类别
   • 函数体内局部变量的类别
   • 函数返回值的类别

2. 函数模版的实例化 Template Instantiation

1. 模版函数（Template Function） 是函数模版的实例化；编译器会在所需位置根据函数模版与参数类型，生成对应的模版函数

   int i = 3, j = 4;
   swap(i, j);    // 实例化 int 类型的 swap
   
   string s("Hello");
   string t("World");
   swap(s, t);    // 实例化 string 类型的 swap
   

2. 函数模版的类型推断

   • 函数模版的传入参数类型必须与参数表完全一致，不支持隐式自动转换
   • 函数模版与一般的同名函数（Regular Functions）按如下规则共存：
     • 优先调用参数类型完全一致的 Regular Function
     • 其次调用参数类型完全一致的函数模版
     • 最后通过隐式类型转换，调用参数类型不完全一致的 Regular Function

   void f(float i, float k);
   
   template <class T>
   void f(T t, T u);
   
   f(1.0f, 2.0f);    // 两个参数都为 float，调用普通函数
   f(1.0, 2.0);      // 两个参数都为 double，调用函数模版
   f(1, 2);          // 两个参数都为 int，调用函数模版
   f(1, 2.0);        // 进行隐式类型转换，将 1、2.0 转换为 1f、2.0f，调用普通函数
   

   <aside> 📌

   在 C++ 中：

   • 形如 2.0f 的常量为 float 类型
   • 形如 2.0 的常量为 double 类型 </aside>

3. 在调用时，可以显式地指明函数模版的类型

   template <class T>
   void foo(){...}
   
   foo<int>();
   foo<float>();
   

三、类模板

1. 类模板的定义

1. 类模版的声明和实现都应放在头文件中

2. 模版可以接收一或多个类型参数

   template <class T>
   class Vector{
   public:
   	Vector(int);
   	~Vector();
   	Vector(const Vector&);
   	Vector& operator=(const Vector&);
   	T& operator[](int);
   	
   private:
   	T* m_elements;
   	int m_size;
   }
   
   Vector<int> v1(100);
   v1[20] = 10;
   

   template <class Key, class Value>
   class HashTable{
   	const Value& lookup(const Key&) const;
   	void insert(const Key&, const Value&);
   };
   

3. 模版可以嵌套，即模版实例可以作为外层模版的类型参数

   Vector < Vector <double> >
   // 一个存储 double 类型的 Vector 的 Vector