Encapsulation de matrice de cas de modèle de classe C ++
Récemment, j'ai pris le temps de regarder des vidéos et des livres C ++. Aujourd'hui, je viens de terminer l'apprentissage de cette partie du modèle de cours, juste pour résumer et analyser le cas dans une vidéo. Ne dites pas de bêtises, commencez simplement.
Les exigences du programme sont les suivantes:
1. Les données des types de données intégrés et des types de données personnalisés peuvent être stockées.
2. Stockez les données du tableau dans la zone de tas.
3. La capacité du tableau peut être transmise au constructeur
4. Fournissez le constructeur de copie correspondant et l'opérateur = pour éviter les problèmes de copie superficielle.
5. Fournissez des méthodes d'interpolation de queue et de suppression de queue pour ajouter et supprimer des données dans le tableau.
6. Les éléments du tableau sont accessibles par indice.
7. Vous pouvez obtenir le nombre actuel d'éléments dans le tableau et la capacité du tableau.
1. La conception globale du programme est analysée.
2. Le programme est réalisé.
1. Tout d'abord, écrivez le programme dans des fichiers.
Ajoutez le fichier d'en-tête pour écrire l'instruction. Les
fonctions membres du modèle de classe étant écrites dans des fichiers, la création l'heure des fonctions membres dans le modèle de classe est dans la phase d'appel, ce qui conduit à la division du fichier. Le lien n'est pas disponible lors de l'écriture, donc ici pour résoudre ce problème, la déclaration et l'implémentation sont écrites dans le même fichier, et le suffixe est changé en **. hpp ** (hpp est un nom de convention, non obligatoire)
2. Écrivez votre propre classe de tableau général dans MyArray
(1) Commencez par écrire un programme standard pour introduire
//自己通用的数组类
#pragma once//防止头文件重复包含
#include<iostream>//标准的io流，头文件引入
using namespace std;//使用标准命名空间
(2) Écrivez quelques propriétés privées qui doivent être maintenues dans la classe MyArray
template<class T>//因为T不识别，故加类模板T
class MyArray
{
private:
T*pAddress;//指针指向堆区开辟的真实数组
int m_Capacity;//数组容量
int m_Size;//数组大小
}
(3) Ensuite, vous devez écrire des fonctions membres externes
public:
//有参构造，写参数和容量
MyArray(int capacity)
{
this->m_Capacity=capacity;//通过参数传入容量
this->m_Size=0;//初始化赋值为0
this->pAddress=new T[this->m_Capacity];//在堆区创建数据
}
//防止浅拷贝提供拷贝构造函数
MyArray(const MyArray& arr)
{
//编译器提供
this->m_Capacity=arr.m_Capacity;
this->m_Size=arr.m_Size;
//this->pAddress=arr.pAddress;//因为编译器这样提供，指针不能这样，会导致堆区数据重复释放
//需要进行深拷贝
this->pAddress=new T[arr.m_Capacity];
//因为原先数组中有数据，需将arr中的数据都拷贝过来
for(int i=0;i<this->m_Size;i++)
{
this->pAddress[i]=arr.pAddress[i];
}
}
//operator= 防止浅拷贝问题故重载符号
MyArray& operator=(const MyArray& arr)
{
//先判断原来堆区是否有数据，如果有先释放
if(this->pAddress!=NULL)
{
delete[]this->pAddress;
this->pAddress=NULL;
this->m_Capacity=0;
this->m_Size=0;
}
//深拷贝
this->m_Capacity=arr.m_Capacity;
this->m_Size=arr.m_Size;
this->pAddress=new T[arr.m_Capacity];
for(int i=0;i<this->m_Size;i++)
{
this->pAddress[i]=arr.pAddress[i];
}
return *this;//最后需要将参数返回
}
//因为堆区创建数据，是手动开辟，手动释放故需要写一个析构函数
//析构函数
~MyArray()
{
if(this->pAddress!=NULL)
{
delete[]this->pAddress;
}
}
(4) Ajouter et supprimer des données dans le tableau par interpolation de queue et suppression de queue
(le code est le suivant :)
//尾插法
void Push_Back(const T & vai)
{
//判断容量是否等于大小，若满了的话无法插入，直接返回
if(this->m_Capacity==this->m_Size)
{
return;
}
this->pAddress[this->m_Size]=vai;//在数组末尾插入数据
this->m_Size++;//更新数组大小
}
//尾删法
void Pop_Back()
{
//让用户访问不到最后一个元素，即为尾删，逻辑删除
if(this->m_Size==0)
{
return;
}
this->m_Size--;
}
(5) Accédez aux éléments du tableau par indice
T& operator[](int index)
{
return this->pAddress[index];
}
(6) Renvoyer la capacité et la taille de la matrice
//返回数组容量
int getCapacity()
{
return this->m_Capacity;
}
//返回数组大小
int getSize()
{
return this->m_Size;
}
(7) Ecrire une fonction d'impression de test et imprimer la capacité et la taille de arr1
//写一个打印函数
void printIntArray(MyArray<int>& arr)
{
for(int i=0;i<arr.getSize();i++)
{
cout<<arr[i]<<endl;
}
}
//写一个测试函数利用尾插法来测试
void test01()
{
MyArray<int>arr1(5);
for(int i=0;i<5;i++)
{
arr1.Push_Back(i);
}
cout<<"arr的打印输出为："<<endl;
printIntArray(arr1);
//测试一下arr的容量以及大小
cout<<"arr1的容量为："<<arr1.getCapacity()<<endl;
cout<<"arr1的大小为："<<arr1.getSize()<<endl;
}
(8) Utilisez la méthode de queue de mesure arr2
MyArray<int>arr2(arr1);
cout<<"arr2的打印输出为："<<endl;
printIntArray(arr2);
//尾删
arr2.Pop_Back();
cout<<"arr2的容量为："<<arr2.getCapacity()<<endl;
cout<<"arr2的大小为："<<arr2.getSize()<<endl;
}
(9) Le résultat du test est comme indiqué dans la figure ci-dessous
(10) Enfin, le test du type de données personnalisé La
fonction de test est la suivante:
//测试自定义数据类型
class Person
{
public:
Person(){
};
Person(string name,int age)
{
this->m_Name=name;
this->m_Age=age;
}
string m_Name;
int m_Age;
};
void printPersonArray(MyArray<Person>& arr)
{
for(int i=0;i<arr.getSize();i++)
{
cout<<"姓名："<<arr[i].m_Name<<"年龄"<<arr[i].m_Age<<endl;
}
}
void test02()
{
MyArray<Person>arr(10);
Person p1("wjx",20);
Person p2("p",20);
Person p3("hh",908);
Person p4("aa",308);
Person p5("999",999);
//将数据插入到数组中
arr.Push_Back(p1);
arr.Push_Back(p2);
arr.Push_Back(p3);
arr.Push_Back(p4);
arr.Push_Back(p5);
//打印数组
printPersonArray(arr);
//输出容量
cout<<"arr容量为："<<arr.getCapacity()<<endl;
//输出大小
cout<<"arr大小为："<<arr.getSize()<<endl;
}
Les résultats du test sont indiqués dans la figure: Ce qui
précède est le cas du modèle de classe que j'ai résumé. Ce cas se sent très bien. La surcharge de paramètres, la copie profonde et la copie superficielle valent la peine d'être apprises. Tout d'abord, j'écrirai un cas général de le modèle de classe. Colonne, j'ai le temps d'écrire d'autres connaissances de base sur le modèle mémorisé au cours des deux dernières semaines, allez!