1.函数模板

第一种
template<typename T> //这T是类型参数

第二种
看看非类型参数怎么用
template<int a, int b>
int func()
{
    int add = a + b;  
    return add;
}
在main中
int result = func<1, 2>;

第三种
template<typename T, int a, int b>
int func(T c)
{
    int add = (int)c + a + b;
    return add;
}
在main中
int result = func<int, 11, 12>(13)   13是实参，int是类型参数
13和int对应，所以就传进去了，如果不是13，而是13.3，那会以<>里面的为准，而不是13

第四种，感觉没见过，所以先不写了

2.类模板

类模板的所有信息，不管是声明还是实现等内容，必须全部写到一个头文件里，因为实例化具体类的时候，需要知道类的所有信息

记住vector才是一个完整的类型

#pragma once
#ifndef __MYVECTOR__
#define __MYVECTOR__

template<typename T>
class myvector
{
public:
    typedef T* myiterator;

public:
    myvector();
    myvector& operator = (const myvector&);

public:
    myiterator mybegin();
    myiterator myend();

public:
    void myfunc();
};

template<typename T>
void myvector<T>::myfunc()
{

}

template<typename T>
myvector<T>::myvector()
{

}
#endif

在类模板内部，可以直接使用类模板名，而不需要在类模板名后跟模板参数，因为在类模板定义内部，如果没提供类模板参数，编译器会假定类模板名带与不带模板参数等价，也就是myvector等价于myvector

当然非要在后面跟模板参数也行

myvector&operator=(const myvector&)

但是假如在类模板定义外实现这个运算符重载，则需要这样写，需要加上模板参数T，这种写法是套路，记住就行

template

myvector& myvector::operator = (const myvector&)

{

return *this;

}

使用非类型的模板参数

template<typename T, int size = 10>
class myarray
{
private:
    T arr[size];

public:
    void myfunc();
};

template<typename T, int size>
void myarray<T, size>::myfunc()
{
    std::cout << size << std::endl;
    return;
}

但这种一般有参数限制，例如浮点型一般不能做非类型模板参数

例如这个就不行

tempalte<typename T, double size>
class myarray{---};

类类型也不能做非类型模板参数，例如

class a
{
    
};
template<typenmae T, a Size>
class myarray{---};