首页 > 其他分享> 文章详细

模版-基础

2021-06-19 19:34:20 阅读：153 来源： 互联网

标签：arr const int 模版基础 Arr len size

类--模具

实例化出来的对象--模具做出来的产品

模版--模具的图纸

模版--实例化--》类(模具)---实例化对象(产品)

一.函数模版

模板和特例化返回值一致，函数名一致，参数格式一致
模板类型是在编译期进行确定，确定好模板类型之后实例化成具体的
函数/类，以供使用

模板是否都会实例化呢？
特例化会直接编译，不用实例化
普通模板只有调用才会编译
模板只有调用了才会实例化，会根据调用的类型实例化出对应的函
数/类
模板在编译期间进行实例化

普通函数>特例化版本>模版

普通函数：整形，浮点型

template<typename T>
bool compare(T a, T  b)//比较  含参
{
    cout << "bool compare(T a, T b)    " << typeid(T).name() << endl;//进行输出   // typeid(T).name() 输出类型名
    return a > b;//若为真  返回值  为假返回0
}

函数模板不能满足个别的类型需求的情况下

函数模板的特例化

函数重载是在编译期确定需要调用的函数
函数模板是在编译期确定需要实例化的函数类型

函数模板实例化出来的多个函数之间是重载关系--包括函数模板的特例化

静多态包含：编译期间的多态，函数重载，模板

函数重载：

bool compare(int a, int b)
{
    cout << "bool compare(int a, int b)" << endl;
    return a > b;
}

bool compare(char a, char b)
{
    return a > b;
}

bool compare(const char* a,const char* b)//传常量字符串
{
    cout << "bool compare(const char* a,const char* b)" << endl;
    return strcmp(a,b) > 0;
}

特例化版本：

字符串：

template<>
bool compare<const char*>(const char* a, const char* b)
{
    cout << "bool compare<const char*>(const char* a, const char* b)" << endl;
    return strcmp(a, b) > 0;
}

冒泡排序的模板特例化

写const char*

普通：

template<typename ZPL>//先指定类型代表
void Msort(ZPL* arr, int len)
{
    if (NULL == arr)
    {
        return;
    }
    ZPL tmp = ZPL();//   相当于int tmp=0;

    for (int i = 0; i < len; i++)
    {
        for (int j = 0; j < len - i - 1; j++)
        {
            if (arr[j] < arr[j + 1])
            {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

特例化：

template<>
void Msort<const char*>(const char** arr, int len)//const char* 又因为是数组 *arr
{
    if (NULL == arr)
    {
        return;
    }
    const char* tmp = NULL;//进行指定

    for (int i = 0; i < len; i++)
    {
        for (int j = 0; j < len - i - 1; j++)
        {
            if (arr[j] && arr[j + 1])//判断他两同时不为空
            {
                if (strcmp(arr[j], arr[j + 1]) < 0)//const char* 时使用strcmp
                {
                    tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }
    }
}

函数模版：

template<typename T>
class Arr
{
private:
    T* _arr;
    int _len;
    int _size;

    void revert()
    {
        _len = _len << 1;
        T* tmp = new T[_len];
        memset(tmp, T(), _len);
        for (int i = 0; i < _size; i++)
        {
            tmp[i] = _arr[i];
        }

        delete[]_arr;
        _arr = tmp;
    }
public:
    Arr(int len = 10);
    Arr(T* arr, int size);
    Arr(const Arr& src);
    ~Arr();
    Arr& operator=(const Arr& src);
    void push_back(T val);
    void sort();
    bool is_full()
    {
        return _size == _len;
    }

    int size()//排序时使用，可不使用友元
    {
        return _size;
    }

    T* get_arr()
    {
        return _arr;
    }

    //template<typename T>//字母T 可换其他字母
    //friend ostream& operator<<(ostream& out, Arr<T>& src);//T可换 
};

template<typename T>//重新定义T
Arr<T>::Arr(int len)//声明作用域Arr<T>   上面是默认值，下面是参数
{
    _len = len;
    _arr = new T[_len];
    memset(_arr, T(), _len);//进行初始化  T类型  默认值为len
    _size = 0;
}

template<typename T>
Arr<T>::Arr(T* arr, int size)
{
    _len = size;
    _size = size;
    _arr = new T[_len];
    memset(_arr, T(), _len);
    for (int i = 0; i < _len; i++)
    {
        _arr[i] = arr[i];
    }
}

template<typename T>
Arr<T>::Arr(const Arr& src)//拷贝构造
{
    _len = src._len;
    _size = src._size;
    _arr = new  T[_len];
    memset(_arr, T(), _len);
    for (int i = 0; i < _size; i++)//防止浅拷贝
    {
        _arr[i] = src._arr[i];
    }
}

template<typename T>
Arr<T>::~Arr()
{
    delete[]_arr;
    _arr = NULL;
    _size = _len = 0;
}

template<typename T>
Arr<T>& Arr<T>::operator=(const Arr& src)//等号运算符
{
    if (&src == this)
    {
        return *this;
    }

    delete _arr;

    _len = src._len;
    _size = src._size;
    _arr = new  T[_len];
    memset(_arr, T(), _len);
    for (int i = 0; i < _size; i++)
    {
        _arr[i] = src._arr[i];
    }

    return *this;
}

template<typename T>
void Arr<T>::push_back(T val)//从后面放
{
    if (is_full())
    {
        revert();//申请空间
    }

    _arr[_size++] = val;
}

template<typename T>
void Arr<T>::sort()//排序
{
    T tmp = T();

    for (int i = 0; i < _size; i++)
    {
        for (int j = 0; j < _size - i - 1; j++)
        {
            if (_arr[j] < _arr[j + 1])
            {
                tmp = _arr[j];
                _arr[j] = _arr[j + 1];
                _arr[j + 1] = tmp;
            }
        }
    }
}





template<typename T>//重新定义T  （Arr<T>中的T）
ostream& operator<<(ostream& out, Arr<T>& src)//类外输出运算符重载
{
    for (int i = 0; i < src.size(); i++)
    {
        cout << src.get_arr()[i] << " ";
    }
    cout << endl;
    return out;
}

标签：arr,const,int,模版,基础,Arr,len,size
来源： https://www.cnblogs.com/xpei-1124/p/14904630.html