0426 嵌入式学习笔记 （30）模板/类模板

模板

参数多态化的工具（根据指定参数类型动态处理）
GC：所谓参数多态化，是指将程序所处理的对象的类型参数化，使一段程序代码可以用于处理不同类型的对象
作用：
采用模板编程，可以为各种逻辑功能相同而数据类型不同的程序提供一种代码共享的机制（模板用于表达逻辑结构相同，但具体数据元素类型不同的数据对象的通用行为）

函数模板：通用函数，用虚拟数据类型代替，等到运行时才进行类型替换
函数模板为所有的函数提供惟一的一段代码函数，增强了函数设计的通用性
使用：
使用函数模板的方法是先说明函数模板，然后实例化成相应的模板函数进行调用执行
函数模板不是函数，不能被执行
置换代码中的类型参数，得到模板函数------实例化
实例化后的模板函数是真正的函数，可以被执行

模板被编译了两次
实例化之前，先检查模板代码本身，查看语法是否正确；这里会发现语法错误，如遗漏分号等；
实例化期间，检查模板代码查看是否所有的调用都有效，这里会发现无效调用，如实例化类型不支持某些函数调用等；
非类型模板参数：template_typename< int name>
模板声明最好都放在.h文件

template< typename T>
void print(Ta,Tb)
{
	cout<<"a-"<<a<<"b-"<<b<<endl;
}

int a =65;
char ch = 'A';
print< int >(a,ch);  //error
print< int >(a,ch);

使用函数模板时，可以进行隐式调用，但是不允许进行隐式类型转换

template< typename T> //T就是虚拟的数字类型

隐式调用：由编译器自行推导数据类型称为隐式调用，不由程序员指定
显式调用：不由编译器推导，由程序员指定数据类型

#include<iostream>
using namespace;

template<typename T>
T add(T a,T b)
int add(int a,int b)
{
    return a+b;
}

int main()
{
    int a = 1,b = 2;
    float c = 1.9,d = 2.0;
    cout<<"int :"<<add(a,b)<<endl;
    cout<<"float:"<<add(c,d)<<endl;//ying shi diao yong

    cout<<add<int>(a,b)<<endl;
    cout<<add<float>(a,c)<<endl;//xian shi diao yong
    return 0;
}

类模板

将类定义中的数据类型参数化
类模板实际上是函数模板的推广，可以用相同的类模板来组件任意类型的对象合集
使用：
类模板的实例化：用具体的数据类型替换模板的参数以得到具体的类（模板类）
模板类也可以实例化为对象

用下列方式创建类模板的实例：
类名<类型实参数>对象名称；

缺省模板参数？
成员模板：
为什么需要成员模板
实例化

类的虚拟数据类型可以和成员函数相同，但是不能和友元函数重名

类外定义的任何函数用到了类的模板都需要进行显式调用

对象在创建时一定要显式调用

#include<iostream>
using namespace std;

class complex
{
    public:
        complex(T a,T b);
        complex()void{}
        void print();
        template<typename T>
        friend complex<T> operator>>(istream &in, complex &B);

        template<typename q>
        friend ostream& operator<<(ostream & out,const complex &C);

        template<typename l>
        friend complex operator+(const complex<l> &A,const complex &B);


    private:
        T m_a;
        T m_b;

};

template<typename T>
complex<T>::complex(T a,T b)
{
    m_a = a;
    m_b = b;
}

templex<typename T>
void complex<T>::print()
{
    cout<<m_a<<"+"<<m_b<<"i"<<endl;
}

temple <typename T>
complex<T> operator>>(istream &in, complex<T> &B)
{
    int x,t;
    scanf("%d%di",&x,&y);
    getchar();
    B.m_a = x;
    B.m_b = y;
    return B;    
}

template<typename q>
ostream& operator<<(ostream &out,const complex<q> &c)
{
    cout<<c.m_a<<"+"<<c.m_b<<"i"<<endl;
}

template<typename l>
complex<l> operator+(const complex<l> &A,const complex<l> &B)
{
    complex<l> C;
    C.m_a = A.m_a + B.m_a;
    C.m_b = A.m_a + B.m_b;
    return C;
}

int main()
{
    complex<int> c;
    complex<int> c1(2,3);
    cin>>c;
    cout<<c<<endl;
    complex<int> c2;
    c2 = c1+c;
    cout<<c2<<endl;

    complex<float> c3(1.1,2.2);
    complex<float> c4(2.3,3.4);
    complex<float> c5;
    c5 = c3 + c4;
    cout<<c5<<endl;

    return 0;
}
`