C++ 实验5（大一下）

实验5：运算符重载与模板类

姓名_____________班级_____________学号______________

• 请阅读此说明：实验5满分100分；做完实验后请按要求将代码和截图贴入该文档。然后将此文档、源代码文件（.hpp, .cpp）打包上传到学习通。

1、（总分100分）在实验4的基础上工作：（20分）❶考虑将myVector类调整为模板类，注意体会模板类和非模板类在程序设计和装配时的差异；（30分）❷实例化一个myVector<myString>的字符串向量类型 ，并按测试程序的要求调整myString的设计 通过测试程序，注意体会模板类实例化的方法和实例化类使用的特点；（30分）❸尝试用该类型写一个主函数完成一个基于选择排序的字符串降序排列工作，注意比较和直接使用myVector内的sort有什么不同？（20分）❹若字符串集合的排序要求为按照字符串的第2个字符至第6个字符构成的子串来完成降序排序（假设每个原始字符串长度都超过10），则考虑你的程序该做怎么样的调整？

实验解答：

❶黏贴模板类myVector的实现代码和调整后的myString的定义代码：

//"myVector.h" 模板类

#pragma once

#include <iostream>

#include <algorithm>

using namespace std;

const int CAPACITY = 1000;

template <class T>

class myVector

{

public:

    //构造

    myVector();

    myVector(int);

    myVector(int, const T);   //用指定值value初始化n个单元，n<=CAPACITY

    myVector(const myVector&);     //拷贝构造

    //重载

    myVector& operator=(const myVector& right); //赋值重载

    T& operator[](int);   //重载下标运算

    myVector& operator-();    //元素逆置

    myVector& operator++();        //前置自增，vector内每个单元值+1

    myVector& operator++(int); //后置自增

    friend myVector operator+(const myVector& left, const myVector& right);    //求两个数组并集

    friend myVector operator-(const myVector& left, const myVector& right);    //求两个数组差集

    friend ostream& operator<<(ostream&, const myVector&);   //输出流重载

    friend istream& operator>>(istream&, myVector&); //输入流重载

    void display() const;     //从0开始显示向量元素，以逗号分隔每个单元值

    void mysort();                 //升序排序

    void set_size(int);       // newsize < CAPACITY

    int get_size() const;     //获取size

private:

    T data[CAPACITY];

    int size;         //有效单元个数

};

template<class T>

myVector<T>::myVector() : size(0) {}

template<class T>

myVector<T>::myVector(int n) : size(n)      //初始化 size 值为n 的myVector

{

    for (int i = 0; i < size; i++)

        data[i] = T();

}

template<class T>

myVector<T>::myVector(int n, const T value) : size(n)

{

    for (int i = 0; i < size; i++)

        data[i] = value;

}

template<class T>

myVector<T>::myVector(const myVector& right) : size(right.size)

{

    for (int i = 0; i < size; i++)

        data[i] = right.data[i];

}

template<class T>

myVector<T>& myVector<T>::operator =(const myVector& right)

{

    size = right.size;

    for (int i = 0; i < size; i++)

        data[i] = right.data[i];

    return *this;

}

template<class T>

T& myVector<T>::operator [](int index)

{

    if (index < size)

        return data[index];

    else return data[CAPACITY];

}

template<class T>

myVector<T>& myVector<T>::operator -()

{

    reverse(data, data + size);

    return *this;

}

template<class T>

myVector<T>& myVector<T>::operator ++()

{

    for (int i = 0; i < size; i++)

        data[i]++;

    return *this;

}

template<class T>

myVector<T>& myVector<T>::operator ++(int)

{

    myVector temp = *this;

    ++(*this);

    return temp;

}

template<class T>

myVector<T> operator +(const myVector<T>& left, const myVector<T>& right)

{

    myVector<T> result = left;

    for (int i = 0; i < right.size; i++)

    {

        bool duplicate = false;

        for (int j = 0; j < left.size; j++)

        {

            if (right.data[i] == left.data[j])

            {

                duplicate = true;

                break;

            }

        }

        if (!duplicate)

            result.data[result.size++] = right.data[i];

    }

    return result;

}

template<class T>

myVector<T> __cdecl operator -(const myVector<T>& left, const myVector<T>& right)   //求两个 Vector 差集

{

    myVector<T> result;

    for (int i = 0; i < left.size; i++)

    {

        bool duplicate = false;

        for (int j = 0; j < right.size; j++)

        {

            if (left.data[i] == right.data[j])

            {

                duplicate = true;

                break;

            }

        }

        if (!duplicate)

            result.data[result.size++] = left.data[i];

    }

    return result;

}

template<class T>

ostream& operator <<(ostream& out, const myVector<T>& v)

{

    for (int i = 0; i < v.size; i++)

    {

        out << v.data[i];

        if (i != v.size - 1)

            out << ",";

    }

    return out;

}

template<class T>

istream& operator >>(istream& in, myVector<T>& v)

{

    for (int i = 0; i < v.size; i++)

        in >> v.data[i];

    return in;

}

template<class T>

void myVector<T>::display() const

{

    for (int i = 0; i < size; i++)

    {

        cout << data[i];

        if (i != size - 1)

            cout << ",";

    }

    cout << endl;

}

template<class T>

void myVector<T>::mysort()

{

    sort(data, data + size);

}

template<class T>

void myVector<T>::set_size(int newsize)

{

    size = newsize > CAPACITY ? CAPACITY : newsize;

}

template<class T>

int myVector<T>::get_size() const

{

    return size;

}

//"myString.h"

#pragma once

class myString

{

public:

    myString()         // 无参数构造函数

    {

        message = NULL;

        length = 0;

    }

    myString(const char* s)   // 带参数构造函数

    {

        length = strlen(s);

        message = new char[length + 1];

        strcpy(message, s);

    }

    ~myString()        // 析构函数

    {

        delete[] message;

        message = NULL;

        length = 0;

    }

    int getLength()    // 获取字符串长度

    {

        return length;

    }

    friend ostream& operator<<(ostream& os, const myString& s)  // 重载<<运算符

    {

        os << s.message;

        return os;

    }

private:

    char* message;     // 存放字符串的字符数组指针

    int length;        // 字符串长度

};

❷黏贴程序测试运行结果窗口（运行结果截屏）：

❸黏贴排序实现代码：

    for (int i = 0; i < aStrSet.get_size(); i++) {

        int max = i;

        for (int j = i + 1; j < aStrSet.get_size(); j++) {

            if (aStrSet[max] < aStrSet[j]) max = j;

        }

        char* temp = aStrSet[i];

        aStrSet[i] = aStrSet[max];

        aStrSet[max] = temp;

    }

❹黏贴基于子串比较规则的排序实现代码 以及你测试的数据和测试的结果（运行结果截屏）；以及说明原来设计的类是否做了调整？若有调整，调整了什么？

  开一个新的myVector 对象存储子串，在对子串排序的同时对原串进行排序。