chapter05.md · llongint/C++ template try

# 5、技巧性基础知识

## 5.1 关键字 typename
C++ 引入关键字 typename 是为了说明：`模板内部的标识符可以是一个类型`
```cpp
template<typename T>
class MyClass {
  typename T::SubType1 *ptr; // SubType1 是 T 内部的一种类型
  T::SubType2 *ptr;          // SubType2 被认为是一个静态成员
};
```
依赖于某个参数的名称是个类型时，就该用 typename.

一个典型的例子，见 [@file](./examples/basics/printcoll.hpp)，在模板代码中访问STL容器的迭代器

### 5.1.1 .tmeplate 构造
当前面(如小于号)存在依赖于模板参数的对象时，才需要在模板内部使用 .template 标记
```cpp
template <int N>
void printBitset(std::bitset<N> const &bs) {
  std::cout<<bs.template to_string<char,char_traits<char>, // bs 依赖模板参数N的构造
              allocator<char> >();
}
```
llvm 源码 FunctionExtras.h 片段：
```cpp
bool isTrivialCallback() const {
  return CallbackAndInlineFlag.getPointer().template is<TrivialCallback *>();
}
CallPtrT getTrivialCallback() const {
  return CallbackAndInlineFlag.getPointer().template get<TrivialCallback *>()->CallPtr;
}
NonTrivialCallbacks *getNonTrivialCallbacks() const {
  return CallbackAndInlineFlag.getPointer()
      .template get<NonTrivialCallbacks *>();
}
```
## 5.2 使用 this
对于那些在基类中声明，并且依赖于模板参数的符号(函数或者变量等)，你应该在前面使用 `this->` 或者 `Base<T>::`
```cpp
template <typename T>
class Base{
  public:void exit();
}
template <typename T>
class Drived:Base<T> {
  public:void foo(){
    exit();     // 这里不会考虑基类的exit(),所以会出错， 或call外部 exit()
  }
}
```
## 5.3 成员模板
类成员可是模板，嵌套类和成员函数都可做模板。

缺省赋值运算符要求两边具有相同的类型，不同时需要定义特定的赋值运算符。

如 [@file](./examples/basics/stack5decl.hpp):
```cpp
template <typename T2>
Stack<T>& operator= (Stack<T2> const&);

// 注意这里传入了两个模板参数
template <typename T>
template <typename T2>
Stack<T>& Stack<T>::operator= (Stack<T2> const& op2){...}
```
现实见 [@file](./examples/basics/stack5assign.hpp). -- 遍历, push

在实现中，可以把内部容器作为一个模板参数，这样就有机会改变内部的容器类型，现实见 [@file](./examples/basics/stack6decl.hpp)：
```cpp
template <typename T, typename CONT = std::deque<T> >
class Stack {
  private:
    CONT elems;            // elements
```
赋值运算符实现见[@file](./examples/basics/stack6assign.hpp)：
```cpp
template <typename T, typename CONT>
 template <typename T2, typename CONT2>
Stack<T,CONT>& 
Stack<T,CONT>::operator= (Stack<T2,CONT2> const& op2)
{...}
```
那我们就能这样用了：
```cpp
Stack<int,std::vector<int>> vStack;
vStack.push(42);
```
C++ 模板库中的 [优先队列](https://zh.cppreference.com/w/cpp/container/priority_queue) 的声明与此类似：
```cpp
template<typename T, typename _Sequence = vector<T>,
	   typename _Compare = less<typename _Sequence::value_type> >
template<
    class T,
    class Container = std::vector<T>,
    class Compare = std::less<typename Container::value_type>
> class priority_queue;
```
可以这样用：
```cpp
struct myComp
{
    constexpr bool operator()(
        pair<int, int> const &a,
        pair<int, int> const &b)
        const noexcept {
        return a.second < b.second;
    }
};
priority_queue<pair<int, int>, vector<pair<int, int>>, myComp> pq1;
```
## 5.4 模板的模板参数 - `难以理解`
借助于模板的模板参数，可以只指定容器的类型而不需给出所含的元素, 见[@file](./examples/basics/stack7decl.hpp)：
```cpp
template <typename T,
          template <typename ELEM> class CONT = std::deque >
class Stack {
  CONT<T> elems;
  ...}
```
两个地方可以注意：
- `CONT<T> elems;`: 这里使用了第一个模板参数作为第二个模板参数的实例化类型
- `template <typename ELEM> class CONT`: 这里的 class 不能用 typename 代替
  - 因为不会用到"模板的模板参数"的模板参数，及ELEM, 所以ELEM可以省略不写

成员函数push:
```cpp
template <typename T, template <typename  class CONT>
void Stack<T, CONT>::push(T const &elem) {
  elems.push_back(elem);
}
```

### 模板的模板实参匹配
为了兼容 std::deque 的第二个参数，我们可以这样声明：见[@file](./examples/basics/stack8.hpp)
```cpp
template <typename T,
          template <typename ELEM, 
                    typename = std::allocator<ELEM> >
                    class CONT = std::deque>
class Stack {...}
```

程序的最终版本 见 [@file](./examples/basics/stack8test.cpp)

## 5.5 零初始化
内建类型如 int、double 不存在`用一个有用的缺省值来进行初始化`的缺省构造函数，但可以显示的调用内建类型的构造函数。
```cpp
template<typename T>
class foo(){
  T x = T();  // 如果T是内建类型，x是零或者false
  public:
  foo():x(){} // 这样也可以
}
```
## 5.6 使用字符串作为函数模板的实参
见 [@file](./examples/basics/max5.cpp)
```cpp
template <typename T>
inline T const& max (T const& a, T const& b) {
    return  a < b  ?  b : a;
}
int main()
{
    std::string s;

::max("apple","peach");   // OK: same type
    ::max("apple","tomato");  // ERROR: different types
    ::max("apple",s);         // ERROR: different types
}
```
由于长度的区别, 'apple' 和 'peach' 具有相同的类型 `char const[6]`; 然而 'tomato' 的类型则是：`char const[7]`

---
`注`：如果声明的是非引用参数，你就可以使用长度不同的字符串来作为max()的参数, 见 [@file](./examples/basics/max6.cpp)
```cpp
template <typename T>
inline T max (T a, T b) {...}
...
::max("apple",s);　　　　// ERROR: 不同的类型
```
原因是：对于非引用类型的参数，在实参演绎的过程中，会出现数组到指针（array-to-pointer）的类型转换（这种转型通常也被称为decay）
见 [@file](./examples/basics/refnonref.cpp)
```cpp
std::cout << "x in ref(T const&): " << typeid(x).name() << '\n';// 对于大多数优秀的C++编译器实现而言，name()会返回一个字符串
```
输出：
```
x in ref(T const&): A6_c
x in nonref(T):     PKc
```
这个问题并没有通用的解决方法, 根据不同的情况，你可以：
- 使用非引用参数，取代引用参数（然而，这可能会导致无用的拷贝）。
- 进行重载，编写接收引用参数和非引用参数的两个重载函数（然而，这可能会导致二义性，具体见附录B.2.2）。
- 对具体类型进行重载（譬如对std::string进行重载）。
- 重载数组类型，譬如：
  ```cpp
  template <typename T, int N, int M>
  T const* max(T const (&a)[N], T const (&b)[M]) {
    return a < b ? b : a;
  }
  ```
- 强制要求应用程序程序员使用显式类型转换。

建议的方法是重载字符串版本，见 [@file](./examples/basics/max3.cpp)， 如：
```cpp
inline std::string max (std::string a, std::string b) { 
    return  a < b ?  b : a;
}
```

## 5.7 小结
- 如果要访问依赖于模板参数的类型名称，你应该在类型名称前添加关键字typename。
- 嵌套类和成员函数也可以是模板。在本章的例子中，针对元素类型可以进行隐式类型转换的2个栈，我们实现了通用的赋值操作。然而，在这种情况下，类型检查依然是存在的。
- 赋值运算符的模板版本并没有取代缺省赋值运算符。
- 类模板也可以作为模板参数，我们称之为模板的模板参数。
- 模板的模板实参必须精确地匹配。匹配时并不会考虑 `模板的模板实参` 的缺省模板实参（如std::deque的allocator）。
- 通过显式调用缺省构造函数，可以确保模板的变量和成员都已经用一个缺省值完成初始化，这种方法对内建类型的变量和成员也适用。
- 对于字符串，在实参演绎过程中，当且仅当参数不是引用时，才会出现数组到指针（array-to-pointer）的类型转换（称为decay）

[ <-- back to readme](./readme.md)

llongint/C++ template try

简介

发行版

贡献者

近期动态

llongint/C++ template try .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

llongint/C++ template try