今天起的很晚。
以下为今天的学习笔记，以后只要没有琐事会天天发的。

.hpp是什么, 怎么用：
为c++的头文件，c++允许在.hpp文件中编写函数体的声明和实现代码。在调用函数时只需要包含其头文件即可。

pragma once

保证程序的不重复编译

模板类的静态成员
模板类中的静态成员变量声明了不同的函数实体将产生不同的静态成员变量。
模板参数:

整形模板参数：
    准确的说是整形常量
    #include <iostream>
    #include <stdexcept>
    using namespace std;
    template<typename T, unsigned size>
    class array
    {
        T elems[size];
        public:
        T& operator[](unsigned i) throw (std::out_of_range) {
        if(i >= size) throw std::out_of_range("array access out of range.");
        else return elems[i];
        }
    };
    int main(void)
    {
        array<int, 10> array0;
        try{array0[11] = 0;}
        catch(std::out_of_range& e)
        {
        cerr<<"Access out of range."<<endl;
        }
        return 0;
    }

函数指针模板参数：
    使用了模板技术实现了类似回调的“静态回调”
    #include <iostream>

    template<typename T , void (*f)(T& v)>
    void foreach(T array[], unsigned size)
    {
        for(unsigned i=0; i<size; i++) f(array[i]);
    }
    template<typename T>
    void inc(T &v)
    {
        ++v;
    }
    template<typename T>
    void dec(T &v)
    {
        --v;
    }
    template<typename T>
    void print(T &v)
    {
        std::cout<<" "<<v<<std::endl;
    }
    int main(void)
    {
        int array[] = {1, 2, 3, 4};
        foreach<int, inc<int> >(array, 4);
        foreach<int, print<int> >(array, 4);
        return 0;
    }
指针引用模板参数：
    指针和引用都要声明成全局变量
    #include <iostream>
    using namespace std;
    template<int *p>
    struct wrapper
    {
       int get(){return *p;}
       void set(int v){*p = v;} 
    };

    int global_variable = 0;
    int main(void)
    {
        wrapper<&global_variable> gwrapper;
        gwrapper.set(1);
        cout<<gwrapper.get()<<endl;
        
        return 0;
    }

类成员函数指针模板参数：
    #include <iostream>
    using namespace std;
    class some_value;
    typedef int (some_value::* some_value_mfp)(int);
    template<some_value_mfp func>
    int call(some_value &value, int op){return (value.*func)(op);}
    class some_value{
        int value ;
        public:
        some_value(int _value):value(_value){}
        int add_by(int op){return value += op;}
    };
    int main(void)
    {
        some_value v0(0);
        cout<<call<&some_value::add_by>(v0, 2)<<endl;
        return 0;
    }
模板型模板参数：
    #include <iostream>
    using namespace std;
    template<template<typename TT> class Func, typename T>
    void foreach(T array[], unsigned size)
    {
        Func<T> func;
        for(unsigned i=0; i<size; ++i) func(array[i]);
    }
    template<typename T>
    struct inc
    {
        void operator()(T& v) const {v++;}   
    };
    template<typename T>
    struct print
    {
        void operator()(T& v) const {cout<<" "<<v;}
    };
    int main(void)
    {
        int array[] = {1,2,3,4,5,6};
        foreach<inc, int>(array, 6);
        foreach<print, int>(array, 6);
        return 0;
    }

异常：超出范围的值抛出的：<stdexcept>头文件下的 std::out_of_rang