案例：数组模板类变容器,算法与数据类型分离

东方耀

案例：数组模板类变容器,算法与数据类型分离


2_MyVector_test.cpp

1. #include <iostream>
   
2. #include <string.h>
   
3. #include "2_MyVector.cpp"
   
4. using namespace std;
   
5. 
   
6. //案例：数组模板类变容器,算法与数据类型分离  放 int char Teacher 的数组 都可以
   
7. 
   
8. class Teacher{
   
9. public:
   
10.     Teacher()
    
11.         {
    
12.         //error: no matching function for call to ‘Teacher::Teacher()’m_space = new T[m_len];
    
13.         //为什么要提供一个 默认构造函数?
    
14.                 this->age = 0;
    
15.                 strcpy(this->name, "");
    
16.         }
    
17.     Teacher(char *name, int age=8){
    
18.         this->age = age;
    
19.         strcpy(this->name, name);
    
20.         
    
21.     }
    
22. public:
    
23.     void printT()
    
24.         {
    
25.                 cout << name << ", 年龄=" << age << endl;
    
26.         }
    
27. private:
    
28.     int age;
    
29.     char name[10];  //这种情况简单 直接分配栈内存空间
    
30. };
    
31. 
    
32. 
    
33. int main(){
    
34. 
    
35.     Teacher t1("t1", 31),t2("t2", 32),t3("t3", 33),t4("t4", 34);
    
36.    
    
37.     MyVector<Teacher> myv1(4);
    
38.     myv1[0] = t1;
    
39.     myv1[1] = t2;
    
40.     myv1[2] = t3;
    
41.     myv1[3] = t4;
    
42. 
    
43.     MyVector<Teacher> myv2(4);
    
44.     myv2 = myv1;  // =操作符重载
    
45.    
    
46.     for(int i=0;i<4;i++){
    
47.         myv2[i].printT();
    
48.     }
    
49. 
    
50.     // cout << myv2;
    
51. 
    
52.     cout << "我的容器类_Teacher复杂数据类型" << endl;
    
53.     return 0;
    
54. }
    
55. 
    
56. int main_char(){
    
57. 
    
58.     MyVector<char> myv1(4);
    
59.     myv1[0] = 'a';
    
60.     myv1[1] = 'b';
    
61.     myv1[2] = 'c';
    
62. 
    
63.     MyVector<char> myv2(10);
    
64.     myv2 = myv1;  // =操作符重载
    
65. 
    
66.     for(int i=0;i<10;i++){
    
67.         cout << myv2[i] << endl;
    
68.     }
    
69. 
    
70.     // cout << myv2;
    
71. 
    
72.     cout << "我的容器类_char" << endl;
    
73.     return 0;
    
74. }
    
75. 
    
76. 
    
77. int main_int(){
    
78. 
    
79.     MyVector<int> myv1(10);
    
80.     for(int i=0;i<10;i++){
    
81.         myv1[i] = i*i;
    
82.         // cout << myv1[i] << endl;
    
83.     }
    
84.     MyVector<int> myv2(10);
    
85.     myv2 = myv1;  // =操作符重载
    
86. 
    
87.     // for(int i=0;i<10;i++){
    
88.     //     cout << myv2[i] << endl;
    
89.     // }
    
90. 
    
91.     // cout << myv2;
    
92. 
    
93.     cout << "我的容器类_int" << endl;
    
94.     return 0;
    
95. }

复制代码

2_MyVector.cpp

1. #include <iostream>
   
2. #include "2_MyVector.h"
   
3. 
   
4. using namespace std;
   
5. 
   
6. 
   
7. 
   
8. //后面有“::”的名称一定是类名或命名空间名
   
9. //error: invalid use of template-name ‘MyVector’ without an argument list
   
10. template <typename T>
    
11. MyVector<T>::MyVector(int size){
    
12.     m_len = size;
    
13.     m_space = new T[m_len];  // 这里会调用T的默认构造函数 如果T是复杂类型的话
    
14.     std::cout << "构造函数!" << std::endl;
    
15. }
    
16. 
    
17. template <typename T>
    
18. MyVector<T>::~MyVector(){
    
19.     if(m_space != NULL){
    
20.         delete [] m_space;
    
21.         m_space=NULL;  //防止野指针
    
22.         m_len = 0;
    
23.     }
    
24.     std::cout << "析构函数!" << std::endl;
    
25. }
    
26. 
    
27. 
    
28. template <typename T>
    
29. T& MyVector<T>::operator[](int index){
    
30.     //返回 T 这样只能当右值啊 不能当左值
    
31.     //返回 T& 既可以当左值 也可以当右值
    
32.     std::cout << "operator[]操作符重载!" << std::endl;
    
33.     return m_space[index];
    
34. }
    
35. 
    
36. 
    
37. //实现 拷贝构造函数 MyVector<int> myv2 = myv1;   // 拷贝构造函数
    
38. template <typename T>
    
39. MyVector<T>::MyVector(const MyVector<T>& obj){
    
40.     m_len = obj.m_len;
    
41.     m_space = new T[m_len];
    
42.     for(int i=0;i<m_len;++i){
    
43.         m_space[i] = obj.m_space[i];
    
44.     }
    
45.     std::cout << "copy构造函数!" << std::endl;
    
46. }
    
47. 
    
48. 
    
49. 
    
50. // myv3 = myv2 = myv1;  // =操作符重载  数组对象
    
51. template <typename T>
    
52. MyVector<T>& MyVector<T>::operator=(const MyVector<T>& obj){
    
53.     //1、先释放自己原来的
    
54.     if(m_space != NULL){
    
55.         delete [] m_space;
    
56.         m_space=NULL;  //防止野指针
    
57.         m_len = 0;
    
58.     }
    
59.     //2、根据新来的申请大小和空间
    
60.     m_len = obj.m_len;
    
61.     m_space = new T[m_len];
    
62.     //3、根据新来的值 拷贝过来
    
63.     for(int i=0;i<m_len;++i){
    
64.         m_space[i] = obj.m_space[i];
    
65.     }
    
66.     std::cout << "operator=操作符重载!" << std::endl;
    
67.     return *this;   //不要忘记返回 自身  适用 三个以上的连等
    
68.    
    
69. }
    
70. 
    
71. 
    
72. // template <typename T>
    
73. // ostream & operator<<(ostream &out,  const MyVector<T> &obj)
    
74. // {
    
75. //         for (int i=0; i<obj.m_len; i++)
    
76. //         {
    
77. //                 out << obj.m_space[i] << " ";
    
78. //                 //out << t1;
    
79. //         }
    
80. //         out << endl;
    
81. //         return out;
    
82. // }
    
83. 
    
84. 
    
85. 
    
86. 
    

复制代码

2_MyVector.h

1. #include <iostream>
   
2. 
   
3. using namespace std;
   
4. 
   
5. // #ifndef __PRE_JUDGE__
   
6. // #define __PRE_JUDGE__
   
7. //如果是int类型的数组    int array[4] = {0,1,2,3};   array[0]
   
8. //类模板的思想：让算法与数据类型进行分离
   
9. 
   
10. //构建一个模板类 数组 根据类型来自动申请分配空间
    
11. 
    
12. template <typename T>
    
13. class MyVector{
    
14.     //friend ostream & operator<< <T>(ostream &out,  const MyVector<T> &obj);
    
15.     //friend ostream & operator<< <T>(ostream &out,  const MyVector &obj);
    
16. public:
    
17.     MyVector(int size=0);
    
18.     ~MyVector();
    
19.     MyVector(const MyVector& obj);
    
20.     T& operator[](int index);
    
21.     MyVector& operator=(const MyVector& obj); //数组对象1=数组对象2
    
22. public:
    
23.         int getLen()
    
24.         {
    
25.                 return m_len;
    
26.         }
    
27. private:
    
28.     int m_len;
    
29.     T *m_space;
    
30. 
    
31. };
    
32. 
    
33. // #endif // __PRE_JUDGE__
    
34. 
    

复制代码

东方耀

优化Teacher类, 属性变成 char *m_pname, 构造函数里面 分配内存

1. #include <iostream>
   
2. #include <string.h>
   
3. #include "2_MyVector.cpp"
   
4. using namespace std;
   
5. 
   
6. //案例：数组模板类变容器,算法与数据类型分离  放 int char Teacher 的数组 都可以
   
7. 
   
8. //1  优化Teacher类, 属性变成 char *m_pname, 构造函数里面 分配内存 析构释放内存
   
9. 
   
10. //2  优化Teacher类,析构函数 释放panme指向的内存空间
    
11. //3  优化Teacher类,避免浅拷贝 重载= 重写拷贝构造函数
    
12. //4  优化Teacher类,在Teacher增加 <<   linux没有成功
    
13. //5  在模板数组类中,存int char Teacher Teacher*(指针类型)
    
14. 
    
15. //=====>stl 容器的概念 入门
    
16. 
    
17. class Teacher{
    
18. public:
    
19.     Teacher()
    
20.         {
    
21.         //error: no matching function for call to ‘Teacher::Teacher()’m_space = new T[m_len];
    
22.         //为什么要提供一个 默认构造函数?
    
23.                 this->age = 0;
    
24.         this->m_pname = new char[1];
    
25.                 strcpy(this->m_pname, "");
    
26.         cout << "Teacher的无参构造函数！" << endl;
    
27.         }
    
28.     Teacher(char *name, int age=8){
    
29.         this->age = age;
    
30.         this->m_pname = new char[strlen(name) + 1];
    
31.         strcpy(this->m_pname, name);
    
32.         
    
33.     }
    
34.     Teacher(const Teacher& obj){
    
35.         this->age = obj.age;  //体会：.与->的区别  easy
    
36.         
    
37.         this->m_pname = new char[strlen(obj.m_pname) + 1];
    
38.         strcpy(this->m_pname, obj.m_pname);
    
39.         
    
40.     }
    
41.     ~Teacher()
    
42.         {
    
43.                 //this->age = 0;
    
44.         if (m_pname != NULL){
    
45.             delete [] m_pname;
    
46.             m_pname = NULL;
    
47.         }
    
48.         cout << "Teacher类的 析构函数！" << endl;
    
49.         }
    
50. public:
    
51.     Teacher& operator=(const Teacher& obj){
    
52.         if (m_pname != NULL){
    
53.             delete [] m_pname;
    
54.             m_pname = NULL;
    
55.         }
    
56.         age = obj.age;
    
57.         m_pname = new char[strlen(obj.m_pname) + 1];
    
58.         strcpy(m_pname, obj.m_pname);
    
59.         cout << "Teacher类的 =操作符重载！" << endl;
    
60.         return *this;
    
61.     }
    
62.     void printT()
    
63.         {
    
64.                 cout << "名字=" <<m_pname << ", 年龄=" << age << endl;
    
65.         }
    
66. private:
    
67.     int age;
    
68.     //char name[10];  //这种情况简单 直接分配栈内存空间 这是固定的空间
    
69.     char *m_pname;     // 程序活起来 名字不用固定长度了 构造函数中动态分配内存空间
    
70. };
    
71. 
    
72. int main(){
    
73. 
    
74.     Teacher t1("t11111111111", 31),t2("t222222222222", 32),t3("t33333333", 33),t4("t44444444444", 34);
    
75.     //t1 = t2; //这个还不行  
    
76.     //Teacher t5 = t3;
    
77.     //t1.printT();
    
78. 
    
79.     MyVector<Teacher> myv1(4);
    
80.     myv1[0] = t1;
    
81.     myv1[1] = t2;
    
82.     myv1[2] = t3;
    
83.     myv1[3] = t4;
    
84. 
    
85.     MyVector<Teacher> myv2(4);
    
86.     myv2 = myv1;
    
87. 
    
88.     for(int i=0;i<4;i++){
    
89.         myv2[i].printT();
    
90.     }
    
91.    
    
92. 
    
93.     cout << "我的容器类_Teacher复杂数据类型" << endl;
    
94.     return 0;
    
95. }
    

复制代码

zouqiqi

让天下人人学会人工智能！人工智能的前景一片大好！