第16章 模板与泛型编程

//template parameter list
template<typename T1,typename T2>
int compare(const T1& v1, const T2&v2)
{
    if (v1 < v2) return -1;
    if (v2 < v1) return 1;
    return 0;
}

// 整数
template<unsigned N, unsigned M>
int compare(const char(&p1)[N], const char(&p2)[M])
{
    strcpy(p1,p2);
}
// 指针
template<const char* C>
void func1(const char* str)
{
    cout << C << " " << str << endl;
}

// 引用
template<char(&R)[9]>
void func2(const char* str)
{
    cout << R << " " << str << endl;
}

// 函数指针
template<void(*f)(const char*)>
void func3(const char* c)
{
    f(c);
}
void print(const char* c) { cout << c << endl; }
char arr[9] = "template";   // 全局变量，具有静态生存期
int main()
{
    func1<arr>("pointer");
    func2<arr>("reference");
    func3<print>("template function pointer");
    return 0;
}

template<typename T1, typename T2> inline int compare(const T1& v1, const T2&v2);
template<typename T1, typename T2> constexpr int compare(const T1& v1, const T2&v2);

//默认模板参数
template<typename T=int>
//使用参数类型的类型成员作为返回值的类型
typename vector<T>::size_type differ(vector<T>& lh, vector<T>& rh)
{
    return lh.size() - rh.size();
}

//为了在unique_ptr析构对象的时候打印出来信息
class DebugDelete
{
public:
    DebugDelete(std::ostream&s = std::cerr) :os(s) {}
    template <typename T> void operator()(T*p)const
    {
        os << "deleting unique_ptr" << std::endl;
        delete p;
    }
private:
    std::ostream &os;
};
int main()
{
    //会生成一个int版本的DebugDelete实例
    unique_ptr<int, DebugDelete> p(new int, DebugDelete());
    return 0;
}

template <typename It>
auto fcn(It beg, It end) -> decltype(*beg)
{
    return *beg;
}

template <typename It>  //第二个typename表示type成员为类型
auto fcn(It beg, It end) -> typename remove_reference<decltype(*beg)>::type
{
    return *beg;
}

template<class _Ty> inline
constexpr typename remove_reference<_Ty>::type&&
move(_Ty&& _Arg) noexcept
{    // forward _Arg as movable
    return (static_cast<typename remove_reference<_Ty>::type&&>(_Arg));
}

std::string s1("hi!"), s2;
s2 = std::move(std::string("bye!"));
s2 = std::move(s1);

s2 = std::move(std::string("bye!"));

s2 = std::move(s1);

template<typename F,typename T1,typename T2>
void flip1(F f, T1 t1, T2, t2)
{
    f(t2, t1);
}

function<void(int, int&)> fun = [](int a, int& b) {cout << a << ++b << endl; };
int a = 1, b = 2;
flip1(fun, a, b);
cout << a << b << endl;

template<typename F,typename T1,typename T2>
void flip1(F f, T1&& t1, T2&& t2)
{
    f(t1, t2);
}

function<void(int&&, int&)> fun = [](int &&a, int& b) {cout << a << ++b << endl; };
int a = 1;
flip1(fun, 1, a);

template<typename F,typename T1,typename T2>
void flip1(F f, T1&& t1, T2&& t2)
{
    f(std::forward<T1>(t1), std::forward<T2>(t2));
}

template<typename T> std::string debug_rep(const T& t)
{
    std::ostringstream ret;
    ret << t;
    return ret.str();
}
template<typename T> std::string debug_rep(T* p)
{
    std::ostringstream ret;
    ret << "pointer: " << p << " " << (p ? debug_rep(*p) : "null pointer");
    return ret.str();
}

int a = 1;
std::cout << debug_rep(a) << std::endl;

int a = 1;
std::cout << debug_rep(&a) << std::endl;

debug_rep(const int*&)
debug_rep(int*)

const int* a = &b;
std::cout << debug_rep(a) << std::endl;

// Args is a template parameter pack; rest is a function parameter pack
// Args represents zero or more template type parameters
// rest represents zero or more function parameters
template <typename T, typename... Args>
void foo(const T &t, const Args& ... rest)
{
    cout << sizeof...(Args) << endl;  // number of type parameters
    cout << sizeof...(args) << endl;  // number of function parameters
}

// function to end the recursion and print the last element
// this function must be declared before the variadic version of print is defined
template<typename T>
ostream &print(ostream &os, const T &t)
{
    return os << t; // no separator after the last element in the pack
}
// this version of print will be called for all but the last element in the pack
template <typename T, typename... Args>
ostream &print(ostream &os, const T &t, const Args&... rest)
{
    os << t << ", ";  // print the first argument
    return print(os, rest...); // recursive call; print the other arguments
}

template <typename T, typename... Args>
ostream &print(ostream &os, const T &t, const Args&... rest) //扩展Args，生成参数列表
{
    os << t << ", ";  
    return print(os, rest...); //扩展实参，形成实参列表
}

print(os, debug_rep(rest)...);

return print(os, debug_rep(p1), debug_rep(p2), debug_rep(p3));

// fun haszero or more parameters each of which is
// an rvalue reference to a template parameter type
template<typename... Args>
void fun(Args&&... args) // expands Args as a list of rvalue references
{
    // the argument to work expands both Args and args
    work(std::forward<Args>(args)...);
}

// firstversion; can compare any two types
template <typename T> int compare(const T&, const T&);
// second version to handle string literals
template<size_t N, size_t M>
int compare(const char(&)[N], const char(&)[M]);

// specialversion of compare to handle pointers to character arrays
template <>
int compare(const char* const &p1, const char* const &p2)
{
    return strcmp(p1, p2);
}

compare("hi", "mom");

// openthe std namespace so we can specialize std::hash
namespace std 
{
    template <>  // we‘re defining a specialization with
    struct hash<Sales_data> // the template parameter of Sales_data
    {
        // the type used to hash an unordered container must define these types
        typedef size_t result_type;
        typedef Sales_data argument_type; // by default, this type needs ==
        size_t operator()(const Sales_data& s) const;
        // our class uses synthesized copy control and default constructor
    };
    size_t hash<Sales_data>::operator()(const Sales_data& s) const
    {
        //下边是hash函数的算法，使用了string、uint、double的hash算法
        return hash<string>()(s.bookNo) ^
            hash<unsigned>()(s.units_sold) ^
            hash<double>()(s.revenue);
    }
}

// needed for the friend declaration
template <classT> class std::hash;  
class Sales_data {
    friend class std::hash<Sales_data>;
    // other members as before
};

template <class T> struct remove_reference {
    typedef T type;
};
// partialspecializations that will be used for lvalue and rvalue references
template <class T> struct remove_reference<T&>  // lvalue references
{
    typedef T type;
};
template <class T> struct remove_reference<T&&> // rvalue references
{
    typedef T type;
};

template <typename T> struct Foo {
    Foo(constT &t = T()) : mem(t) { }
    void Bar() { /* ...*/ }
    T mem;
    // other members of Foo
};
template<>  // we‘re specializing a template
void Foo<int>::Bar() // we‘re specializing the Bar member of Foo<int>
{
    // do whatever specialized processing that applies to ints
}