AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C++ 简单实现数组类泛型编程示例

2017-03-24 1217
版权
举报
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 原创： C++ 简单实现数组类泛型编程示例 1、使用模板来实现泛型编程 2、本数组应该能够存储各种基础类型，各种复杂的类类型 3、应该实现部分操作符重载 其实操作符重载满满的都是套路。
原创：
C++ 简单实现数组类泛型编程示例

1、使用模板来实现泛型编程
2、本数组应该能够存储各种基础类型，各种复杂的类类型
3、应该实现部分操作符重载


其实操作符重载满满的都是套路。


代码如下：

点击(此处)折叠或打开

  1. 模板类实现：
  2. /*************************************************************************
  3.     > File Name: arra.cpp
  4.     > Author: gaopeng QQ:22389860 all right reserved
  5.     > Mail: gaopp_200217@163.com
  6.     > Created Time: Mon 10 Apr 2017 08:28:01 AM CST
  7.  ************************************************************************/

  9. #include<iostream>
  10. #include <stdlib.h>
  11.  #include <string.h>
  12. using namespace std;


  15. template <typename T>
  16. class myarray
  17. {
  18.         private:
  19.                 T* array;
  20.                 unsigned int lenth;
  21.         public:
  22.                 myarray();
  23.                 myarray(unsigned int len);
  24.                 myarray(const myarray& a);
  25.                 myarray& operator=(const myarray& b);
  26.                 T& operator[](int ind);
  27.                 ~myarray();
  28. };




  33. template <typename T>
  34. myarray<T>::~myarray()
  35. {
  36.         if(this->array != NULL)
  37.         {
  38.                 delete [] this->array;
  39.                 this->array = NULL;
  40.         }

  42. }


  45. template <typename T>
  46. myarray<T>::myarray()
  47. {
  48.         this->array = NULL;
  49.         this->lenth = 0;
  50. }

  52. template <typename T>
  53. myarray<T>::myarray(unsigned int len)
  54. {
  55.         this->array = new T[len];
  56.         this->lenth = len;
  57.         memset(this->array,0,sizeof(T)*len);
  58. }
  59. template <typename T>
  60. myarray<T>::myarray(const myarray<T>& a)
  61. {
  62.         int i;
  63.         this->lenth = a.lenth;
  64.         this->array = new T[a.lenth];
  65.         memset(this->array,0,sizeof(T)*a.lenth);
  66.         for(i=0;i<a.lenth;i++)
  67.         {
  68.                 *(this->array+i) = *(a.array+i);
  69.         }
  70. }

  72. template <typename T>
  73. myarray<T>& myarray<T>::operator=(const myarray<T>& a)
  74. {
  75.         if(this->array != NULL)
  76.         {
  77.                 delete [] this->array;//调用类的析构函数不能用free
  78.                 this->array = NULL;
  79.         }
  80.         this->array = new T[a.lenth];
  81.         this->lenth = a.lenth;

  83.         for(int i=0;i<a.lenth;i++)
  84.         {
  85.                 *(this->array+i) = *(a.array+i);//元素对象复制调用对象的=操作符重载
  86.         }

  88.         return *this;
  89. }

  91. template <typename T>
  92. T& myarray<T>::operator[](int ind)
  93. {
  94.         if(ind>=this->lenth)
  95.         {
  96.                 exit(10);
  97.         }
  98.         return *(this->array+ind);
  99. }


点击(此处)折叠或打开

  1. 测试
  2. /*************************************************************************
  3.     > File Name: main.cpp
  4.     > Author: gaopeng QQ:22389860 all right reserved
  5.     > Mail: gaopp_200217@163.com
  6.     > Created Time: Mon 10 Apr 2017 08:31:57 AM CST
  7.  ************************************************************************/

  9. #include<iostream>
  10. #include<stdlib.h>
  11. #include<string.h>
  12. #include"arra.cpp"

  14. using namespace std;

  16. class test
  17. {
  18.         private:
  19.                 int a;
  20.                 int b;
  21.                 char* myc;
  22.         public:
  23.                 test()
  24.                 {
  25.                         a = 0;
  26.                         b = 0;
  27.                         myc = NULL;
  28.                 }
  29.                 test(const test& a)
  30.                 {
  31.                         this->a = a.a;
  32.                         this->b = a.b;
  33.                         this->myc = (char*)calloc(strlen(a.myc)+1,0);
  34.                         strcpy(this->myc,a.myc);
  35.                 }


  38.                 friend ostream& operator<<(ostream& out,test& a)
  39.                 {
  40.                         out<<a.a<<endl;
  41.                         out<<a.b<<endl;
  42.                         cout<<a.myc;
  43.                         return out;
  44.                 }
  45.                 ~test()
  46.                 {
  47.                         if(myc != NULL)
  48.                         {
  49.                                 free(myc);
  50.                                 myc = NULL;
  51.                         }
  52.                 }

  54.                 test& operator=(const test& a)
  55.                 {
  56.                         if(this->myc != NULL)
  57.                         {
  58.                                 free(this->myc);
  59.                                 this->myc = NULL;
  60.                         }
  61.                         this->a = a.a;
  62.                         this->b = a.b;
  63.                         this->myc = (char*)calloc(strlen(a.myc)+1,0);
  64.                         strcpy(this->myc,a.myc);
  65.                         return *this;
  66.                 }

  68.                 test& operator=(const char* a)
  69.                 {
  70.                         if(this->myc != NULL)
  71.                         {
  72.                                 free(this->myc);
  73.                                 this->myc = NULL;
  74.                         }
  75.                         if(a == NULL)
  76.                         {
  77.                                 this->myc = (char*)calloc(1,0);
  78.                                 return *this;
  79.                         }

  81.                         this->myc = (char*)calloc(strlen(a)+1,0);
  82.                         strcpy(this->myc,a);
  83.                         return *this;
  84.                 }

  86. };



  90. int main()
  91. {
  92.         myarray<test> a(3); //测试class类数组
  93.         a[0] = "asdasd";
  94.         a[1] = "test";
  95.         a[2] = "kkkk";

  97.         myarray<int> b(3); //测试int数组

  99.         b[0] = 1;
  100.         b[1] = 2;
  101.         b[2] = 3;

  103.         myarray<char> c(3); //测试char数组

  105.         c[0] = 'a';
  106.         c[1] = 'b';
  107.         c[2] = 'c';

  109.         myarray<test> d = a;//测试myarray拷贝构造函数

  111.         for(int i=0;i<3;i++)
  112.         {
  113.                 cout<<a[i]<<endl;
  114.                 cout<<d[i]<<endl;
  115.         }

  117.         for(int i=0;i<3;i++)
  118.         {
  119.                 cout<<b[i]<<endl;
  120.         }
  121.         for(int i=0;i<3;i++)
  122.         {
  123.                  cout<<c[i]<<endl;
  124.         }

  126. }



文章标签：
C++
测试技术
关键词：
C++编程
C++类
C++数组
C++泛型
C++泛型编程
重庆八怪
+关注
661文章
目录
打赏
0
0
0
0
91
分享
相关文章
平凡程序猿~
|
16天前
|
编译器 C++ 开发者
【C++篇】深度解析类与对象（下）
在上一篇博客中，我们学习了C++的基础类与对象概念，包括类的定义、对象的使用和构造函数的作用。在这一篇，我们将深入探讨C++类的一些重要特性，如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象，以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念，提升代码的健壮性、灵活性和可维护性。
平凡程序猿~
35 0
平凡程序猿~
|
16天前
|
存储 缓存 C++
C++ 容器全面剖析：掌握 STL 的奥秘，从入门到高效编程
C++ 标准模板库（STL）提供了一组功能强大的容器类，用于存储和操作数据集合。不同的容器具有独特的特性和应用场景，因此选择合适的容器对于程序的性能和代码的可读性至关重要。对于刚接触 C++ 的开发者来说，了解这些容器的基础知识以及它们的特点是迈向高效编程的重要一步。本文将详细介绍 C++ 常用的容器，包括序列容器（`std::vector`、`std::array`、`std::list`、`std::deque`）、关联容器（`std::set`、`std::map`）和无序容器（`std::unordered_set`、`std::unordered_map`），全面解析它们的特点、用法
平凡程序猿~
19 1
C++ 容器全面剖析：掌握 STL 的奥秘，从入门到高效编程
平凡程序猿~
|
16天前
|
存储 算法 C++
深入浅出 C++ STL：解锁高效编程的秘密武器
C++ 标准模板库（STL）是现代 C++ 的核心部分之一，为开发者提供了丰富的预定义数据结构和算法，极大地提升了编程效率和代码的可读性。理解和掌握 STL 对于 C++ 开发者来说至关重要。以下是对 STL 的详细介绍，涵盖其基础知识、发展历史、核心组件、重要性和学习方法。
平凡程序猿~
19 0
平凡程序猿~
|
16天前
|
存储 安全 算法
深入理解C++模板编程：从基础到进阶
在C++编程中，模板是实现泛型编程的关键工具。模板使得代码能够适用于不同的数据类型，极大地提升了代码复用性、灵活性和可维护性。本文将深入探讨模板编程的基础知识，包括函数模板和类模板的定义、使用、以及它们的实例化和匹配规则。
平凡程序猿~
20 0
平凡程序猿~
|
16天前
|
安全 编译器 C语言
【C++篇】深度解析类与对象（中）
在上一篇博客中，我们学习了C++类与对象的基础内容。这一次，我们将深入探讨C++类的关键特性，包括构造函数、析构函数、拷贝构造函数、赋值运算符重载、以及取地址运算符的重载。这些内容是理解面向对象编程的关键，也帮助我们更好地掌握C++内存管理的细节和编码的高级技巧。
平凡程序猿~
17 0
平凡程序猿~
|
16天前
|
存储 程序员 C语言
【C++篇】深度解析类与对象（上）
在C++中，类和对象是面向对象编程的基础组成部分。通过类，程序员可以对现实世界的实体进行模拟和抽象。类的基本概念包括成员变量、成员函数、访问控制等。本篇博客将介绍C++类与对象的基础知识，为后续学习打下良好的基础。
平凡程序猿~
61 0
羑悻的小杀马特
|
18天前
|
编译器 C语言 C++
类和对象的简述（c++篇）
类和对象的简述（c++篇）
羑悻的小杀马特
62 28
RossyYan
|
2月前
|
C++ 芯片
【C++面向对象——类与对象】Computer类（头歌实践教学平台习题）【合集】
声明一个简单的Computer类，含有数据成员芯片（cpu）、内存（ram）、光驱（cdrom）等等，以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制，用于保护类的数据不被外部随意修改。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。成员可以在派生类（继承该类的子类）中访问。成员，在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务，你需要掌握。
RossyYan
74 19
RossyYan
|
2月前
|
存储 编译器 数据安全/隐私保护
【C++面向对象——类与对象】CPU类（头歌实践教学平台习题）【合集】
声明一个CPU类，包含等级（rank）、频率（frequency）、电压（voltage）等属性，以及两个公有成员函数run、stop。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中，类是创建对象的蓝图。类的声明定义了类的成员，包括数据成员（变量）和成员函数（方法）。一个简单的类声明示例如下： classMyClass{ public: int
RossyYan
63 13
RossyYan
|
2月前
|
编译器 数据安全/隐私保护 C++
【C++面向对象——继承与派生】派生类的应用（头歌实践教学平台习题）【合集】
本实验旨在学习类的继承关系、不同继承方式下的访问控制及利用虚基类解决二义性问题。主要内容包括： 1. **类的继承关系基础概念**：介绍继承的定义及声明派生类的语法。 2. **不同继承方式下对基类成员的访问控制**：详细说明`public`、`private`和`protected`继承方式对基类成员的访问权限影响。 3. **利用虚基类解决二义性问题**：解释多继承中可能出现的二义性及其解决方案——虚基类。 实验任务要求从`people`类派生出`student`、`teacher`、`graduate`和`TA`类，添加特定属性并测试这些类的功能。最终通过创建教师和助教实例，验证代码
RossyYan
61 5

热门文章

最新文章

  • 1
    嵌入式C++、STM32、MySQL、GPS、InfluxDB和MQTT协议数据可视化
    3
  • 2
    彻底摘明白 C++ 的动态内存分配原理
    17
  • 3
    类和对象的简述（c++篇）
    3
  • 4
    c++ linux通过实现独立进程之间的通信和传递字符串 demo
    8
  • 5
    【C++篇】深度解析类与对象（上）
    10
  • 6
    模拟实现c++中的vector模版
    1
  • 7
    从集思录可转债数据探秘：Python与C++实现的移动平均算法应用
    6
  • 8
    模拟实现c++中的list模版
    3
  • 9
    员工屏幕监控系统之 C++ 图像差分算法
    1
  • 10
    【C++篇】深度解析类与对象（下）
    3
  • 1
    C++入门基础
    8
  • 2
    【c++】模板详解(2)
    19
  • 3
    公司监控上网软件架构：基于 C++ 链表算法的数据关联机制探讨
    14
  • 4
    【c++丨STL】priority_queue（优先级队列）的使用与模拟实现
    40
  • 5
    C++ noexcept 关键字的关键作用
    25
  • 6
    彻底摘明白 C++ 的动态内存分配原理
    96
  • 7
    C++ 容器全面剖析：掌握 STL 的奥秘，从入门到高效编程
    19
  • 8
    C++ String揭秘：写高效代码的关键
    28
  • 9
    深入浅出 C++ STL：解锁高效编程的秘密武器
    19
  • 10
    深入理解C++模板编程：从基础到进阶
    20

    • 相关课程

    更多
  • C++ 入门教程开发文档
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言核心编程 - 数据结构和算法
  • Python语言基础 - 函数、面向对象、异常处理
  • Java面向对象编程

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce

    • 相关实验场景

    更多
  • 面向对象-1：类的定义
  • 对象和接口-2：常见用法
  • 函数类型-3：函数重载
  • 语言入门-2：基本类型
    • 下一篇
    通义万相：视觉生成大模型再进化