C++的泛型编程方式

1.使用类模板创建数组

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

#pragma once

template<class T>
class MyArray
{
public:
    //有参构造
    MyArray(int capacity)
    {
        mCapacity = capacity;
        mSize = 0;
        pAdress = new T[mCapacity];
    }
    //拷贝构造
    MyArray(const MyArray& my1)
    {
        this->mCapacity = my1.mCapacity;
        this->mSize = my1.mSize;
        this->pAdress = new T[mCapacity];
        for (int i = 0; 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 = 0; 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 = 0;
            mSize = 0;
        }
    }


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(10);
    for (char i = 'a'; i <= 'j'; i++)
        arr.pushBack(i);
    for (int i = 0; i < 10; i++)
        cout << arr[i]<<"  ";
}

//自定义类型
class person
{
public:
    //无参构造
    person()
    {
        this->mName = new char[strlen("undefined!") + 1];
        strcpy(this->mName, "undefined!");
        mAge = -1;
    }
    //有参构造
    person(char *name, int age)
    {
        mName = new char[strlen(name) + 1];
        strcpy(mName, name);
        mAge = age;
    }
    //拷贝构造
    person(const person& p1)
    {
        mName = new char[strlen(p1.mName) + 1];
        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) + 1];
        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) + 1];
        strcpy(mName, ch);
    }
    //析构函数
     ~person()
    {
        if (mName)
        {
            cout << "析构函数" << endl;
            delete[] mName;
            mName = NULL;
        }
    }
public:
    char *mName;
    int mAge;
};

//自定义类型
void test022()
{
    //自定义类型必须提供默认构造函数
    MyArray<person> arr(10);
    /*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 = 0; i < 10; i++)
    {                                            //这段代码是上段代码的加强版，有了sendName()这个函数，它具有两个功能，
        char buf[100];                            //1.它把对象指针原来指向的内存空间先释放了，
        sprintf(buf, "%d%dasafqwdqwdqwdsa%d%d", i, i, i + 1, i + 1);    //2.然后再重新申请赋值长度大小的内存，给他进行了赋值。
        arr[i].sendName(buf);                //3.由于sprintf()函数的特点，这里得创建一个缓存空间，足够大，将赋值的内容先拷贝进去，然后再把这个内存空间传入sendName()函数。
        arr[i].mAge = i + 10;
    }
    //这两段代码最主要的区别是：
        1.第一段赋值代码没有进行原内存的释放，但同时也没有申请新内存，一旦赋值的长度超过其初始化 mName 的内存，就造成了内存泄漏。
        2.第二段赋值代码增加了一个赋值函数，这个函数具有两个功能，（1）释放 mName 原有的内存，（2）对 mName 进行新内存的动态申请。
        3.由于这个函数所传参数的限制，以及 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 = 0; i < 10; i++)
        cout << "Name:" << arr[i].mName << " Age:" << arr[i].mAge << endl;
}

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

    system("pause");
    return EXIT_SUCCESS;
}