（九）C++基础 模板

一、目的和要求

1.掌握函数模板的声明及模板函数的生成
2.掌握类模板的使用方法

二、具体内容

1.实现下列功能。
1)定义学生类包含姓名和成绩两个数据成员，重载比较运算符（按成绩和按姓名两个模式比较）和输出运算符。

2)实现greater_than函数模板，用于比较两个对象的大小，如果a>b，返回true，否则返回fasle。(注意字符串的比较需要将函数模板特化)

3)实现less_than函数模板，用于比较两个对象的大小，如果a<b，返回true，否则返回fasle。(注意字符串的比较需要将函数模板特化)
4)实现Print函数模板，用于打印一维数组。

5)实现冒泡排序（也可以使用其它排序算法，自己喜欢就好了）的函数模板，输入参数是数组、数组大小和用于比较的数组元素的函数指针。

#include "stdafx.h"
#include "iostream"
#include "string"
using namespace std;

class Student {
public:
    enum SortType { BY_NAME, BY_SCORE };
    static SortType sort_type;
    Student (string name, int score) :name_ (name), score_ (score) {
        name_ = name;
        score_ = score;
    }
    bool operator > (const Student& rhs) {
        switch (sort_type)
        {
        case Student::BY_NAME:
            if (rhs.name_ > this->name_) {
                return true;
            }
            else {
                return false;
            }
            break;
        case Student::BY_SCORE:
            if (rhs.score_ > this->score_) {
                return true;
            }
            else {
                return false;
            }
            break;
        default:
            break;
        }
    }
    bool operator < (const Student& rhs) {
        switch (sort_type)
        {
        case Student::BY_NAME:
            if (rhs.name_ < this->name_) {
                return true;
            }
            else {
                return false;
            }
            break;
        case Student::BY_SCORE:
            if (rhs.score_ < this->score_) {
                return true;
            }
            else {
                return false;
            }
            break;
        default:
            break;
        }
    }
    friend ostream& operator << (ostream& os, Student& student) {
        os << student.name_ << " " << student.score_;
        return os;
    }
private:
    string name_;
    int score_;
};

Student::SortType Student::sort_type = Student::BY_NAME;

template<class T>
bool greater_than (T a, T b) {
    return a > b ? true : false;
}

template<class T>
bool less_than (T a, T b) {
    return a < b ? true : false;
}

template<class T>
void Print (T arr[], int len) {
    for (int i = 0; i < len; i++) {
        cout << arr[i]<<" ";
    }
    cout << endl;
}
template<class T>
void bubble_sort (T arr[], int len, bool (*compare)(T&, T&)) {
    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - i - 1; j++) {
            if ((*compare)(arr[j], arr[j + 1])) {
                swap (arr[j], arr[j + 1]);
            }
        }
    }
}

int main () {
    int int_array[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
    int len = (int) sizeof (int_array) / sizeof (*int_array);
    cout << "origin int array:" << endl;
    Print (int_array, len);
    bubble_sort (int_array, len, greater_than);
    cout << "sort: ascending order:" << endl;
    Print (int_array, len);
    bubble_sort (int_array, len, less_than);
    cout << "sort: descending order:" << endl;
    Print (int_array, len);

    cout << "\n----------华丽的分割线 666-----------------\n" << endl;

    float float_array[] = { 17.5f, 19.1f, 0.6f, 1.9f, 10.5f, 12.4f, 3.8f, 19.7f, 1.5f, 25.4f, 28.6f, 4.4f, 23.8f, 5.4f };
    len = (int) sizeof (float_array) / sizeof (*float_array);
    cout << "origin float array:" << endl;
    Print (float_array, len);
    bubble_sort (float_array, len, greater_than);
    cout << "sort: ascending order:" << endl;
    Print (float_array, len);
    bubble_sort (float_array, len, less_than);
    cout << "sort: descending order:" << endl;
    Print (float_array, len);

    //cout << "\n----------华丽的分割线 666-----------------\n" << endl;  

    //注释部分是关于C语言的字符串比较，需要重载模板函数，有兴趣可以做，没兴趣就当注释。  
    /*const char* const_char_array[] = { "ye", "meng", "jie" };
    len = (int) sizeof(const_char_array) / sizeof(*const_char_array);
    cout << "origin float array:" << endl;
    Print(const_char_array, len);
    bubble_sort(const_char_array, len, greater_than);
    cout << "sort: ascending order:" << endl;
    Print(const_char_array, len);
    bubble_sort(const_char_array, len, less_than);
    cout << "sort: descending order:" << endl;
    Print(const_char_array, len);*/

    cout << "\n----------华丽的分割线 666-----------------\n" << endl;

    Student student_array[] = { Student ("ye",100), Student ("meng",60), Student ("jie",70) };
    len = (int) sizeof (student_array) / sizeof (*student_array);
    //sort by name  
    cout << "sort student object by name------" << endl;
    Student::sort_type = Student::BY_NAME;
    cout << "origin student array:" << endl;
    Print (student_array, len);
    bubble_sort (student_array, len, greater_than);
    cout << "sort by name: ascending order:" << endl;
    Print (student_array, len);
    bubble_sort (student_array, len, less_than);
    cout << "sort by name: descending order:" << endl;
    Print (student_array, len);

    cout << "\n----------华丽的分割线 666-----------------\n" << endl;

    //sort by score  
    cout << "sort student object by score------" << endl;
    Student::sort_type = Student::BY_SCORE;
    cout << "origin student array:" << endl;
    Print (student_array, len);
    bubble_sort (student_array, len, greater_than);
    cout << "sort by score: ascending order:" << endl;
    Print (student_array, len);
    bubble_sort (student_array, len, less_than);
    cout << "sort by score: descending order:" << endl;
    Print (student_array, len);
    return 0;
}

运行结果：

2.实现一个动态数组类模板。

#include "stdafx.h"
#include "iostream"
#include "string"
using namespace std;

template<class T>
class DynamicArray
{
public:
    //默认构造函数，可以设置数组容量为1， 数组长度为0  
    DynamicArray ()
    {
        capacity_ = 1;
        size_ = 0;
        data_ = new T[capacity_];
    }
    //给定数组长度构造动态数组  
    DynamicArray (size_t capacity)
    {
        capacity_ = capacity;
        size_ = 0;
        data_ = new T[capacity_];
        //to do list   
    }
    //从数组中构造动态数组  
    DynamicArray (T arr[], size_t size)
    {
        size_ = size;
        capacity_ = arr.capacity_;
        data_ = new T[capacity_];
        for (int i = 0; i < size_; i++) {
            data_[i] = arr.data_[i];
        }
        //to do list    
    }
    //拷贝构造函数  
    DynamicArray (const DynamicArray& rhs)
    {
        size_ = rhs.size_;
        capacity_ = rhs.data_;
        data_ = new T[capacity_];
        for (int i = 0; i < size_; i++) {
            data_[i] = rhs.data_[i];
        }
        //to do list    
    }

    //复制运算符  
    DynamicArray& operator=(const DynamicArray& arr)
    {
        if (data_ != NULL) {
            delete[] data_;
            data_ = NULL;
        }
        size_ = arr.size_;
        capacity_ = arr.capacity_;
        data_ = new T[arr.capacity_];
        for (int i = 0; i < size_; i++)
        {
            data_[i] = arr.data_[i];
        }
        return *this;
        //to do list  
    }
    //析构函数，释放内存  
    ~DynamicArray ()
    {
        delete[] data_;
        //to do list  
    }
    //检查动态数组容量，如果数组长度>=数组容量，重新分配内存空间，并将原始数据复制到新空间，通常新的容量是原来的容量的2倍  
    void check_capacity ()
    {
        if (size_ >= capacity_) {
            capacity_ = capacity_ * 2;
        }
        //to do list    
    }
    //数组末尾添加一个元素，添加元素之前应该检查数组容量是否足够  
    void push_back (const T& item)
    {
        if (capacity_ <= size_) {
            return;
        }
        data_[size_] = item;
        size_++;
        //to do list   
    }
    //删除最后一个元素，只需将数组长度减一即可
    void pop_back ()
    {
        if (size_ == 0) {
            return;
        }
        size_--;
        //to do list  
    }
    //在pos位置插入元素，插入元素之前应该检查数组容量是否足够  
    void insert (size_t pos, const T& item)
    {
        if (capacity_ <= size_) {
            return;
        }
        if (pos<0 || pos>size_) {
            pos = size_;
        }
        for (int i = size_; i >= pos; i--) {
            data_[i + 1] = data_[i];
        }
        data_[pos] = item;
        size_++;
        //to do list  
    }
    //返回数组长度
    size_t size () const
    {
        return size_;
    }
    //返回数组容量 
    size_t capacity () const
    {
        return capacity_;
    }
    //下标运算符重载[],返回pos位置的元素 
    T& operator[](size_t pos)
    {
        return data_[pos];
        //to do list  
    }
  
    void Print () const{
        for (int i = 0; i < size_; i++)
        {
            cout << data_[i] << " ";
        }
        cout << endl;
    }

private:
    T* data_; //数据指针  
    size_t capacity_; //动态数组容量  
    size_t size_; //动态数组长度  
};

int main () {
    DynamicArray<int> a(10);
    int b = 7,c = 8,d = 6,e = 5;
    cout << "添加："  << endl;
    a.push_back (b);
    a.Print ();
    a.push_back (c);
    a.Print ();
    a.push_back (d);
    a.Print ();
    a.push_back (e);
    a.Print ();
    cout << endl;
    cout << "删除：" << endl;
    a.pop_back ();
    a.Print ();
    cout << endl;
    cout << "插入：" << endl;
    a.insert (3, e);
    a.Print ();
    a.insert (2, b);
    a.Print ();
    return 0;
}

运行结果：