数组类模板

已于 2023-09-30 13:47:54 修改
阅读量537 收藏 4
点赞数 2
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-02-22 11:43:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51691366/article/details/129158939
版权

要求：

设计一个数组模板类（MyArray），完成对不同类型元素的管理

操作步骤

设计头文件

在 qtcreate下先创建03_code的项目，然后右键点击03_code添加新文件，点击头文件，点击Choose

命名为 myarry.hpp，其中 .hpp是头文件和源文件结合的一种，一般头文件 .h 是定义类模板，而.cpp 实现类模板的公共方法操作，但是这种方式存在问题，所以为了方便我们操作，C++可以直接使用 .hpp 实现定义类模板和实现它的公共操作方法

设计模板类


#ifndef MYARRY_HPP
#define MYARRY_HPP
#include <iostream>
#include <string.h>
using namespace std;
template <class T>
class MyArry{
    template <typename T1>
    friend ostream & operator<<(ostream &out,MyArry<T1> ob);
private:
    T *arry;  //保存数组地址
    int size; //大小
    int capacity; //容量
public:
    //无参构造
    MyArry();
    //有参构造
    MyArry(int capacity);
    //拷贝构造
    MyArry(MyArry &ob);
    //析构函数
    ~MyArry();
    //重载运算符，完成深拷贝
    MyArry & operator=(MyArry &ob);
    //输入函数
    void pushBack(T elem);
};
#endif // MYARRY_HPP

公共方法实现

无参构造

因为没有参数，所以指针为空，其余参数为 0


//无参构造 成员变量初始化
template<class T>
MyArry<T>::MyArry()
{
    arry = NULL;
    size = 0;
    capacity = 0;
}

有参构造


//有参构造 成员变量赋值
template<class T>
MyArry<T>::MyArry(int capacity)
{
    this->capacity = capacity;
    arry = new T[this->capacity];
    size = 0;
    //清空数组
    memset(arry,0,sizeof(T)*capacity);
}

拷贝构造

拷贝构造本质是构造函数

在上面的代码中，旧对象给新对象初始化就会调用拷贝构造函数

目的是为了在结束的时候新对象也会调用析构函数释放掉新创建的堆区空间，而不会造成新旧对象前后释放指针变量指向的同一块堆区空间，造成多次释放


//拷贝构造
template<class T>
MyArry<T>::MyArry(MyArry &ob)
{
    //ob没有空间，拷贝的空间也没有
    if (ob.arry == NULL){
        arry = NULL;
        size = 0;
        capacity = 0;
    }
    //ob有空间，所以即将拷贝的也有空间
    else{
        capacity = ob.capacity;
        size = ob.size;
        //申请堆区数组空间
        arry = new T[capacity];
        //将旧堆区空间的值复制到新堆区空间
        memcpy(arry,ob.arry,sizeof(T)*capacity);
    }
}

析构函数


//析构函数,释放堆区空间
template<class T>
MyArry<T>::~MyArry()
{
    if(arry != NULL){      //若堆区空间为空就不用析构
        delete [] arry;
    }
}

重载运算符，完成 “=”深拷贝

返回值是引用类型是因为可以链式操作完成 “=”深拷贝，即 ........ob3 = ob2 = ob1 = ob，返回值依然是一个 MyArry<T> 类型，MyArry<T> 必不可少，因为它模板类名 MyArry 和 T 一起完整的描述了是一个如何的返回值


//深拷贝的时候完成赋值重载运算符  ob1 = ob2
template<class T>
MyArry<T> &MyArry<T>::operator=(MyArry &ob)
{
    //判断 this->arry是否存在空间
    if(this->arry != NULL){
       delete [] arry;
       arry = NULL;
    }
    capacity = ob.capacity;
    size = ob.size;
    //申请数组堆区空间
    arry = new T[capacity];
    //将旧堆区空间的值复制到新堆区空间
    memset(arry,0,sizeof(T)*capacity);
    //将旧堆区空间的值复制到新堆区空间
    memcpy(arry,ob.arry,sizeof(T)*capacity);
    //链式完成赋值重载运算符，返回左边运算符的引用
    return *this;
}

插入函数


//输入函数
template<class T>
void MyArry<T>::pushBack(T elem)
{
    if (size == capacity){  //满
        //扩展容量
        capacity = (capacity == 0?1:2*capacity);
        //根据容量申请空间
        T *temp = new T[capacity];
        //无参构造没有给空间的代价，因为无参构造中 size == capacity
        if(arry != NULL){
            //将旧空间的内容拷贝到新空间
            memcpy(temp,arry,sizeof(T)*size);
            //释放旧空间
            delete [] arry;
        }
        arry = temp;
    }
    arry[size] = elem;
    size++;
    return;
}

全局输出函数

注意：类模板的T和函数模板的T1不能重名

这里使用全局函数定义是因为 cout<< ob中cout和 类的实例化对象不是同一个对象（也就是cout不是我们自定义的类型），而ob是我们自定义的对象，而cout 是系统自带的，不能像后面的Person 类一样重载 > 运算符定义为成员函数实现（因为 > 两边都是Person在比较）。


//全局函数重载
//注意：类模板的T和函数模板的T1不能重名
template <typename T1>
ostream & operator<<(ostream &out,MyArry<T1> ob){
    int i;
    for(i = 0; i<ob.size;i++){
        out<<ob.arry[i]<<endl;
    }
    return out;
}

代码实现

MyArry.hpp头文件中的代码实现


#ifndef MYARRY_HPP
#define MYARRY_HPP
#include <iostream>
#include <string.h>
using namespace std;
template <class T>
class MyArry{
    template <typename T1>
    friend ostream & operator<<(ostream &out,MyArry<T1> ob);
private:
    T *arry;  //保存数组地址
    int size; //大小
    int capacity; //容量
public:
    //无参构造
    MyArry();
    //有参构造
    MyArry(int capacity);
    //拷贝构造
    MyArry(MyArry &ob);
    //析构函数
    ~MyArry();
    //重载运算符，完成深拷贝
    MyArry & operator=(MyArry &ob);
    //插入函数
    void pushBack(T elem);
};
#endif // MYARRY_HPP

//无参构造 初始化
template<class T>
MyArry<T>::MyArry()
{
    arry = NULL;
    size = 0;
    capacity = 0;
}

//有参构造 成员变量赋值
template<class T>
MyArry<T>::MyArry(int capacity)
{
    this->capacity = capacity;
    arry = new T[this->capacity];
    size = 0;
    //清空数组
    memset(arry,0,sizeof(T)*capacity);
}

//拷贝构造
template<class T>
MyArry<T>::MyArry(MyArry &ob)
{
    //ob没有空间，拷贝的空间也没有
    if (ob.arry == NULL){
        arry = NULL;
        size = 0;
        capacity = 0;
    }
    //ob有空间，所以即将拷贝的也有空间
    else{
        capacity = ob.capacity;
        size = ob.size;
        //申请堆区数组空间
        arry = new T[capacity];
        //将旧堆区空间的值复制到新堆区空间
        memcpy(arry,ob.arry,sizeof(T)*capacity);
    }
}

//析构函数
template<class T>
MyArry<T>::~MyArry()
{
    if(arry != NULL){      //若堆区空间为空就不用析构
        delete [] arry;
    }
}

//深拷贝的时候完成赋值重载运算符  ob1 = ob2
template<class T>
MyArry<T> &MyArry<T>::operator=(MyArry &ob)
{
    //判断 this->arry是否存在空间
    if(this->arry != NULL){
       delete [] arry;
       arry = NULL;
    }
    capacity = ob.capacity;
    size = ob.size;
    //申请数组堆区空间
    arry = new T[capacity];
    //将旧堆区空间的值复制到新堆区空间
    memset(arry,0,sizeof(T)*capacity);
    //将旧堆区空间的值复制到新堆区空间
    memcpy(arry,ob.arry,sizeof(T)*capacity);
    //链式完成赋值重载运算符，返回左边运算符的引用
    return *this;
}

//输入函数
template<class T>
void MyArry<T>::pushBack(T elem)
{
    if (size == capacity){  //满
        //扩展容量
        capacity = (capacity == 0?1:2*capacity);
        //根据容量申请空间
        T *temp = new T[capacity];
        //无参构造没有给空间的代价，因为无参构造中 size == capacity
        if(arry != NULL){
            //将旧空间的内容拷贝到新空间
            memcpy(temp,arry,sizeof(T)*size);
            //释放旧空间
            delete [] arry;
        }
        arry = temp;
    }
    arry[size] = elem;
    size++;
    return;
}

//全局函数重载
//注意：类模板的T和函数模板的T1不能重名
template <typename T1>
ostream & operator<<(ostream &out,MyArry<T1> ob){
    int i;
    for(i = 0; i<ob.size;i++){
        out<<ob.arry[i]<<endl;
    }
    return out;
}

main.cpp中的测试代码实现如下


#include <iostream>
#include "myarry.hpp"
using namespace std;

int main(int argc, char *argv[])
{
   MyArry<int> ob(5);
   ob.pushBack(10);
   ob.pushBack(20);
   ob.pushBack(30);
   ob.pushBack(40);
   ob.pushBack(50);
   cout<<ob<<endl;

   cout<<"------------------------------------"<<endl;

   MyArry<char> ob1(5);
   ob1.pushBack('a');
   ob1.pushBack('b');
   ob1.pushBack('c');
   ob1.pushBack('d');
   ob1.pushBack('e');
   cout<<ob1<<endl;
   return 0;
}

代码测试

在main.cpp中测试自定义类型


#include <iostream>
#include "myarry.hpp"
using namespace std;

class Person{
private:
    int num;
    string name;
    int score;
public:
    Person(){};
    Person(int num,string name,int score){
        this->num = num;
        this->name = name;
        this->score = score;
    }
};

int main(int argc, char *argv[])
{
   MyArry<int> ob(5);
   ob.pushBack(10);
   ob.pushBack(20);
   ob.pushBack(30);
   ob.pushBack(40);
   ob.pushBack(50);
   cout<<ob<<endl;

   cout<<"------------------------------------"<<endl;

   MyArry<char> ob1(5);
   ob1.pushBack('a');
   ob1.pushBack('b');
   ob1.pushBack('c');
   ob1.pushBack('d');
   ob1.pushBack('e');
   cout<<ob1<<endl;

   cout<<"------------------------------------"<<endl;

   MyArry<Person> ob3;
   ob3.pushBack(Person(123,"ml",99.9));
   ob3.pushBack(Person(456,"ll",100.0));
   ob3.pushBack(Person(789,"ll",100.0));
   ob3.pushBack(Person(101,"ll",100.0));
   ob3.pushBack(Person(111,"ll",100.0));
   cout<<ob3S<<endl;
   return 0;
}

遍历出错，原因 Person 找不到输出运算符

解决方法是让 Person 重载输出运算符，并且要设置该函数为 Person 类的友元函数，便于访问 Person 的私有属性


#include <iostream>
#include "myarry.hpp"
using namespace std;

class Person{
    friend ostream & operator<<(ostream &out,Person ob);
private:
    int num;
    string name;
    int score;
public:
    Person(){};
    Person(int num,string name,int score){
        this->num = num;
        this->name = name;
        this->score = score;
    }
};

//设置为 Person 类的友元，便于访问 Person 的私有属性
ostream & operator<<(ostream &out,Person ob){
    out<<ob.num<<" "<<ob.name<<" "<<ob.score<<endl;
    return out;
}


int main(int argc, char *argv[])
{
   MyArry<int> ob(5);
   ob.pushBack(10);
   ob.pushBack(20);
   ob.pushBack(30);
   ob.pushBack(40);
   ob.pushBack(50);
   cout<<ob<<endl;

   cout<<"------------------------------------"<<endl;

   MyArry<char> ob1(5);
   ob1.pushBack('a');
   ob1.pushBack('b');
   ob1.pushBack('c');
   ob1.pushBack('d');
   ob1.pushBack('e');
   cout<<ob1<<endl;

   cout<<"------------------------------------"<<endl;

   MyArry<Person> ob3;
   ob3.pushBack(Person(123,"ml",99.9));
   ob3.pushBack(Person(456,"ll",100.0));
   ob3.pushBack(Person(789,"ll",100.0));
   ob3.pushBack(Person(101,"ll",100.0));
   ob3.pushBack(Person(111,"ll",100.0));
   cout<<ob3<<endl;
   return 0;
}

打印成功

在MyArry.hpp中添加模板类 MyArry 的公共排序函数如下

函数实现


//冒泡排序
template<class T>
void MyArry<T>::sortArry()
{
    if(arry == NULL){
        cout<<"容器为空！";
    }
    else{
        int i = 0,j = 0;
        for(i = 0;i < size -1;i++){
            for(j = 0;j < size - i -1;j++){
                if(arry[j] > arry[j+1]){
                    T temp = arry[j];
                    arry[j] = arry[j+1];
                    arry[j+1] = temp;
                }
            }
        }
    }
    return;
}

代码测试

可以看到对于基本类型的确是能够进行正确的排序

但是对于前面自定义的复杂类型，却不能进行排序，编译出错

这是因为当 ob3 无参构造之后调用排序函数 sortArry 的时候，在排序中不识别 > 运算符，所以只需要对 Person 进行 > 运算符重载

在Person 类中重载 > 运算符

ob1 > ob2 两个都是Person，所以使用成员函数实现


#include <iostream>
#include "myarry.hpp"
using namespace std;

class Person{
    friend ostream & operator<<(ostream &out,Person ob);
private:
    int num;
    string name;
    int score;
public:
    Person(){};
    Person(int num,string name,int score){
        this->num = num;
        this->name = name;
        this->score = score;
    }
    //Person类重 > 载运算
    bool operator >(const Person ob){
        return num > ob.num;
    }
};

//设置为 Person 类的友元，便于访问 Person 的私有属性
ostream & operator<<(ostream &out,Person ob){
    out<<ob.num<<"       "<<ob.name<<"       "<<ob.score<<endl;
    return out;
}


int main(int argc, char *argv[])
{
   MyArry<int> ob(5);
   ob.pushBack(10);
   ob.pushBack(80);
   ob.pushBack(30);
   ob.pushBack(60);
   ob.pushBack(50);
   cout<<ob<<endl;
   ob.sortArry();
   cout<<ob<<endl;

   cout<<"------------------------------------"<<endl;

   MyArry<char> ob1(5);
   ob1.pushBack('a');
   ob1.pushBack('g');
   ob1.pushBack('c');
   ob1.pushBack('m');
   ob1.pushBack('b');
   cout<<ob1<<endl;
   ob1.sortArry();
   cout<<ob1<<endl;

   cout<<"------------------------------------"<<endl;

   MyArry<Person> ob3;
   ob3.pushBack(Person(123,"ml",99.9));
   ob3.pushBack(Person(456,"hhh",100.0));
   ob3.pushBack(Person(789,"kkk",100.0));
   ob3.pushBack(Person(101,"bb",100.0));
   ob3.pushBack(Person(111,"vvv",100.0));
   cout<<ob3<<endl;
   ob3.sortArry();
   cout<<ob3<<endl;
   return 0;
}

代码测试

总结

模板类定义好之后，对于自定义类型，不要修改模板类的代码，只需要根据需要对自定义类型进行相应的运算符重载即可

运算符重载：就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型，对当前类进行运算符重载，而不修改模板类中的代码

语法：定义重载运算符就像定义函数，只是该函数的名字是 operator@，这里的@代表了被重载的运算符

思路：

  1. 弄懂运算符的运算对象的个数。（个数决定了重载运算符的个数）

  1. 识别运算符左边的运算对象，是自定义类的对象还是其他

运算符两边都是类的对象：全局函数实现不推荐（因为还要设置该函数为友元函数，访问类的私有属性），但是可以直接实现为成员函数，因为类的成员函数可以直接访问类的私有属性，并且少一个参数

其他：只能是全局函数实现

实例：

全局函数重载 cout<<ob输出

成员函数重载 Person.num > Person.num

Q渡劫
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
C++模板类的示例——数组
Crush_66的博客
05-14 1448
private:public:~Array(){}//这个类没有用到堆区内存，析构函数什么都不做//在函数中可以判断数组下标ii的合法性}//重载操作符[]，形参是数组下标，可以修改数组中的元素}//重载操作符[]，形参是数组下标，不可以修改数组中的元素int main()//创建模板类Array的对象aa[0]=5;aa[1]=8;aa[2]=3;aa[3]=2;aa[4]=7;ii
C++类模板数组
CodeHouse的博客
08-20 2315
#include <iostream> #include <string> using namespace std; /************************************************************************ 数组模板类 1.内置数据类型和自定义数据类型进行存储 2.将数组中的数据存储到堆区 3.构造函数中传入数组的容量 4.提供对应的拷贝构造函数以及operator=防止浅拷贝问题 5.提供尾插法和尾删法对数组中的数据进行增
60、数组类模板
xiebs的博客
09-17 706
1、预备知识 模板参数可以是数值型参数（非类型参数） template < typename T, int N > void func() { T a[N]; //使用模板参数定义局部数组 } func<float, 10>(); 数值型模板参数的限制 — 变量不能作为模板参数 — 浮点数不能作为模板参数 — 类对象不能作为模板参数 — … 本质：模......
C++模板 类模板案例 通用的数组类
UUUUU22的博客
03-09 858
C++模板，类模板案例-通用的数组类，要求、需求分析、实现步骤、注意事项、代码展示与效果
大数类模板
blues 的博客
05-25 350
大数类模板 #define MAXN 9999 #define MAXSIZE 10 #define DLEN 4 class BigNum { private: int a[500]; //可以控制大数的位数 int len; //大数长度 public: BigNum(){ len = 1; memset(a, 0, sizeof(a
C++动态数组类模板
11-20
动态数组类模板Array C++ //数组类模板声明 template class Array { public: Array(int sz = 50); Array(const Array<T> &A); ~Array(void); Array<T>& operator = (const Array<T> &rhs;); //重载=,使数组...
一维数组类模板的设计与实现
04-07
建立一维数组数据结构的模板类，使一维数组中的数据元素可以是char, int, float等多种数据类型，类中的成员函数主要包括： 排序函数，能够对数组元素进行升序排列； 查找函数，能够在输入待查元素后，输出其在数组中...
基于数组模板类的排序操作
12-24
选择不同类型的数据类型，完成数组数据的排序操作，排序分别为单向冒泡排序，双向冒泡排序和快速排序。
类模板实践-可变长数组类.7z
06-12
这个项目可能包含了一个源代码文件，如"类模板实践-可变长数组类.cpp"，以及解决方案文件"类模板实践-可变长数组类.sln"，还有Visual Studio的相关配置文件".vs"。 首先，让我们理解类模板的基本概念。类模板定义了...
数组特化模板类
12-18
泛型容器的设计实现大多只是存储了类型的单个对象，而没有存储类型的多个对象，如果有这样特定的需求，容器内的元素要求都是某个类型的多个对象，那么这时就可以考虑用模板类的数组特化来实现了
c++之类模板和函数模板
m0_72647108的博客
08-17 628
C++提供了函数模板(function template.)所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。凡是函数体相同的函数都可以用这个模板代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现不同函数的功能。c++提供两种模板机制:函数模板和类模板类属-类型参数化，又称参数模板。注意：当普通函数和函数模板都存在的时候，会优先调用普通函数。模板的分类：函数模板、类模板。类模板 派生出 普通类。..
STL教程2-MyArray框架实现
baidu_41553551的博客
06-20 380
能够存放任何类型数据，实现初始化，=符号重载，右值引用，内存释放1、类成员变量 容量 int mCapacity; 现有元素 int mSize; 数据的首地址int *pAddr; 2、类函数 在class上面加入template< class T> 3、MyArray(const MyArray& arr) 4、T& operator[](int index) 5、MyArray operator=(const MyArray& arr) 6、void PushBack(T&& data)
C++基础09-货物售卖和MyArray实现
weixin_38383877的博客
08-11 487
1、货物出货与进货 #if 0 #include<iostream> using namespace std; /* 某商店经销一种货物。货物购进和卖出时以箱为单位。各箱 的重量不一样，因此商店需要记录目前库存的总重量，现在用 C++模拟商店货物购进和卖出的情况 */ class Goods { public: Goods() { weight = 0; next = N...
oj 贵州大学 第四次作业（c++）（运算符重载）第四题
m0_63058493的博客
05-20 1726
记录学习日常
黑马程序员——数组类模板
weixin_45686898的博客
03-18 403
MyArray.h //自己的通用的数组类 #pragma once #include<iostream> using namespace std; template<class T> class MyArray { private: T* pAddr; int m_Capacity; int m_Size; public: //有参构造 MyArray(int capacity) { //cout << "有参构造" << endl;
树状数组（入门附模板）
cyyyyds857的博客
06-21 1868
树状数组或二叉索引树（英语：Binary Indexed Tree），又以其发明者命名为Fenwick树，最早由Peter M. Fenwick于1994年以A New Data Structure for Cumulative Frequency Tables为题发表在SOFTWARE PRACTICE AND EXPERIENCE。其初衷是解决数据压缩里的累积频率（Cumulative Frequency）的计算问题，现多用于高效计算数列的前缀和， 区间和。——源自百度百科。
C++ 多态
最新发布
wxk2227814847的博客
07-10 605
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
设计数组类模板Array
06-01
好的，这里是一个简单的数组类模板Array的设计： ```c++ template class Array { private: T* data; // 数组的数据部分 int size; // 数组的大小 public: // 构造函数，创建指定大小的数组 Array(int size) {...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Q渡劫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值