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;
}
