C++的泛型编程方式

1.使用类模板创建数组

下面这段代码：是创建一个元素为 T 类型的数组。

 #pragma once

 template<class T>
 class MyArray
 {
 public:
     //有参构造
     MyArray(int capacity)
     {
         mCapacity = capacity;
         mSize = ;
         pAdress = new T[mCapacity];
     }
     //拷贝构造
     MyArray(const MyArray& my1)
     {
         this->mCapacity = my1.mCapacity;
         this->mSize = my1.mSize;
         this->pAdress = new T[mCapacity];
         for (int i = ; i < mSize; i++)
             pAdress[i] = my1.pAdress[i];
     }
     //重载等号操作符
     MyArray& operator=(const MyArray& my1)
     {
         if (this->pAdress != NULL)
         {
             delete[] pAdress;
             this->pAdress = NULL;
         }
         this->mCapacity = my1.mCapacity;
         this->mSize = my1.mSize;
         this->pAdress = new T[mCapacity];
         for (int i = ; i < mSize; i++)
             pAdress[i] = my1.pAdress[i];
         return *this;
     }
     //重载[]号操作符
     T& operator[](int index)
     {
         return this->pAdress[index];
     }

     //尾插法
     void pushBack(T val)
     {
         if (mSize == mCapacity)
             return;
         pAdress[mSize] = val;
         mSize++;
     }
     //尾部删除法
     void popBack()
     {
         mSize--;
     }
     ~MyArray()
     {
         if (this->pAdress)
         {
             delete[] pAdress;
             pAdress = NULL;
             mCapacity = ;
             mSize = ;
         }
     }

 private:
     T* pAdress;            //指向数组的指针
     int mCapacity;
     int mSize;
 };

2.下面这段代码：是利用上面的模板创建了两个数组（一个是基本数据类型，一个是自定义的类型）

 #define _CRT_SECURE_NO_WARNINGS
 #include<iostream>
 using namespace std;
 #include"MyArray.hpp"

 //普通类型
 void test021()
 {
     MyArray<char> arr();
     for (char i = 'a'; i <= 'j'; i++)
         arr.pushBack(i);
     for (int i = ; i < ; i++)
         cout << arr[i]<<"  ";
 }

 //自定义类型
 class person
 {
 public:
     //无参构造
     person()
     {
         this->mName = new char[strlen("undefined!") + ];
         strcpy(this->mName, "undefined!");
         mAge = -;
     }
     //有参构造
     person(char *name, int age)
     {
         mName = new char[strlen(name) + ];
         strcpy(mName, name);
         mAge = age;
     }
     //拷贝构造
     person(const person& p1)
     {
         mName = new char[strlen(p1.mName) + ];
         strcpy(mName, p1.mName);
         mAge = p1.mAge;
     }

     //重载等号操作符
     person& operator=(const person& p1)
     {
         if (mName != NULL)
         {
             delete[] mName;
             mName = NULL;
         }
         mName = new char[strlen(p1.mName) + ];
         strcpy(mName, p1.mName);
         mAge = p1.mAge;
         return *this;
     }
     //对 mName的赋值函数
     void sendName(const char * ch)
     {
         if (mName)
         {
             delete[] mName;
             mName = NULL;
         }
         mName = new char[strlen(ch) + ];
         strcpy(mName, ch);
     }
     //析构函数
      ~person()
     {
         if (mName)
         {
             cout << "析构函数" << endl;
             delete[] mName;
             mName = NULL;
         }
     }
 public:
     char *mName;
     int mAge;
 };

 //自定义类型
 void test022()
 {
     //自定义类型必须提供默认构造函数
     MyArray<person> arr();
     /*for (int i = 0; i < 10; i++)                    //当初写这段代码时，与下面代码的区别是没有 sendName() 这个函数。此时采用这种赋值方式有两个隐患
     {                                            //1.因为自定义的类中有无参构造函数，对对象的每个变量进行了赋值。由于其中一个变量是指针，那么此时它就具有了空间指向。
         sprintf(arr[i].mName, "%d%dasafqwdqwdqwdsa%d%d", i, i, i + 1, i + 1);        //2.这时直接赋值是对对象的初始化内容进行替换，并没有申请新内存，而此时对象的指针由于经过初始化，具有了
         arr[i].mAge = i + 10;                    //固定大小的内存，一旦赋值超出其长度，就会造成内存泄漏。只有当赋值的内存小于初始化长度时，才不会造成错误。
     }*/
     for (int i = ; i < ; i++)
     {                                            //这段代码是上段代码的加强版，有了sendName()这个函数，它具有两个功能，
         char buf[];                            //1.它把对象指针原来指向的内存空间先释放了，
         sprintf(buf, "%d%dasafqwdqwdqwdsa%d%d", i, i, i + , i + );    //2.然后再重新申请赋值长度大小的内存，给他进行了赋值。
         arr[i].sendName(buf);                //3.由于sprintf()函数的特点，这里得创建一个缓存空间，足够大，将赋值的内容先拷贝进去，然后再把这个内存空间传入sendName()函数。
         arr[i].mAge = i + ;
     }
     //这两段代码最主要的区别是：
         .第一段赋值代码没有进行原内存的释放，但同时也没有申请新内存，一旦赋值的长度超过其初始化 mName 的内存，就造成了内存泄漏。
         .第二段赋值代码增加了一个赋值函数，这个函数具有两个功能，（）释放 mName 原有的内存，（）对 mName 进行新内存的动态申请。
         .由于这个函数所传参数的限制，以及 sprintf()函数的使用特点，只有设置一个足够大的缓冲内存，将赋值的内容先拷贝进缓冲内存，
         再把缓冲内存做实参传给赋值函数，实现对 mName 的赋值。
     /*person p1("john1", 19);
     person p2("john2", 29);
     person p3("john3", 39);
     person p4("john4", 49);
     person p5("john5", 59);
     arr[1] = p1;
     arr.pushBack(p2);
     cout << "Name:" << arr[0].mName << " Age:" << arr[0].mAge << endl;
     arr.pushBack(p3);
     cout << "Name:" << arr[1].mName << " Age:" << arr[1].mAge << endl;*/

     for (int i = ; i < ; i++)
         cout << "Name:" << arr[i].mName << " Age:" << arr[i].mAge << endl;
 }

 int main()
 {
     test022();
     test021();

     system("pause");
     return EXIT_SUCCESS;
 }