类模板的总体实现练习

àì夳堔傛蜴生んèń 2023-10-18 18:02 40阅读 0赞

涉及到很多知识点：

1：深拷贝与浅拷贝与野指针

2：拷贝构造函数与赋值运算符

3：左移运算符重载，取址运算符重载

4：容器执行插入元素操作

5：类模板的实现

teacher.cpp

#pragma once
    #include<iostream>
    using namespace std;
    
    enum title{ Professor, AsscioateProfessor, Lecture, NONE};
    
    class teacher
    {
    	//左移运算符的重载也比较重要
    	friend ostream& operator<<(ostream& out, const teacher& target)
    	{
    		out << "name: " << target.m_name << " age:" << target.m_age << " title:" << target.m_title << endl;;
    		return out;
    	}
    public:
    	teacher(char *name = "test", int age = 0,title title = NONE)
    	{
    		m_age = age;
    		m_name = name;
    		m_title = title;
    	}
    
    	//拷贝构造函数依旧是构造函数，没有返回值，函数名即为类名
    	teacher (const teacher& right)
    	{
    		int temp_size = 0;
    		int i = 0;
    		while (right.m_name[i] != '\0')
    		{
    			i++;
    		}
    		m_name = new char[i+1];
    		for (int j=0;j<i;j++)
    		{
    			m_name[j] = right.m_name[j];
    		}
    		m_name[i] = '\0';
    
    		m_age = right.m_age;
    		m_title = right.m_title;
    	}
    
    	//赋值运算符重载
    	teacher& operator=(const teacher& right)
    	{
    		int temp_size = 0;
    		int i = 0;
    		while (right.m_name[i] != '\0')
    		{
    			i++;
    		}
    		m_name = new char[i + 1];
    		for (int j = 0; j<i ; j++)
    		{
    			m_name[j] = right.m_name[j];
    		}
    		m_name[i] = '\0';
    
    		m_age = right.m_age;
    		m_title = right.m_title;
    		return *this;
    	}
    
    	~teacher()
    	{
    		if (m_name != NULL)
    		{
    			delete[]m_name;
    			m_name = NULL;
    		}
    		m_age = -1;
    		m_title = NONE;
    	}
    private:
    	//涉及到深拷贝，浅拷贝的问题,深拷贝必须实现拷贝构造函数和赋值运算符
    	char *m_name;
    	
    	int m_age;
    	title m_title;
    };

Myvector.cpp

#pragma once
    
    #include<iostream>
    using namespace std;
    
    template<typename T>
    class Myvector
    {
    	friend ostream& operator<<(ostream& out, const Myvector<T>& target)
    	{
    		for (size_t i=0;i<target.m_len;i++)
    		{
    			out << target.m_array[i] << " ";
    		}
    		return out;
    	}
    public:
    	//构造函数
    	Myvector(int size)
    	{
    		m_len = size;
    		m_array = new T[size];
    	}
    	//析构函数
    	~Myvector()
    	{
    		//避免野指针
    		if (m_array != NULL)
    		{
    			delete[]m_array;
    			m_array = NULL;
    			m_len = 0;
    		}
    	}
    	//拷贝构造函数，分配内存，拷贝
    	Myvector (const Myvector& right)
    	{
    		cout << "Myvector 拷贝构造函数" << endl;
    		this->m_len = right.m_len;
    		this->m_array = new T[m_len];
    
    		for (size_t i = 0; i<m_len; i++)
    		{
    			this->m_array[i] = right.m_array[i];
    		}
    	}
    	//
    	//
    public:
    	//取址运算符重载[]
    	//这里注意要加引用，不加引用的话，返回值只能当右值
    	T& operator[](int index)
    	{
    		return m_array[index];
    	}
    	//赋值运算符重载=，三步:释放内存，分配内存，拷贝
    	//该方法为深拷贝，重新分配了内存，新指针的操作不会影响到原有的内存
    	Myvector& operator=(const Myvector& right)
    	{
    		cout << "Myvector 赋值运算符" << endl;
    		//先释放本身内存
    		if (m_array != NULL)
    		{
    			delete[]m_array;
    			m_array = NULL;
    			m_len = 0;
    		}
    
    		//根据right分配内存
    		this->m_len = right.m_len;
    		this->m_array = new T[m_len];
    
    		//拷贝数据
    		for (size_t i = 0; i<m_len; i++)
    		{
    			this->m_array[i] = right.m_array[i];
    		}
    
    		//返回自身的引用
    		//只有返回一个引用，才能进行连续赋值。
    		//否则，如果函数的返回值是void，则应用改赋值运算符将不能进行连续赋值。
    		//假设有3个Person对象：p1、p2、p3，在程序中语句p1=p2=p3将不能通过编译。
    		return *this;
    	}
    protected:
    	int m_len;
    	T *m_array;
    };

main.cpp

//实现一个Myvector的类模板
    
    #include<iostream>
    
    #include"Myvector.h"
    #include"teacher.h"
    using namespace std;
    
    int main()
    {
    	Myvector<int> vector1(5);
    	for (size_t i=0;i<5;i++)
    	{
    		vector1[i] = i;
    	}
    	cout << vector1 << endl;
    
    	Myvector<int> vector2 = vector1;//使用拷贝构造函数
    	cout << vector2 << endl;
    
    	Myvector<int> vector4(5);
    	vector4 = vector1;//使用赋值运算符
    
    
    	teacher alice( "alice", 25, Lecture);
    	teacher bob( "bob", 32, Lecture);
    	teacher cinge( "cinge", 27, AsscioateProfessor);
    	teacher drag( "drag", 45, Professor);
    
    	Myvector<teacher> vector3(4);
    
    	//容器执行插入元素操作时，内部使用拷贝的操作，所以插入的元素必须能够被拷贝，也就是必须有拷贝构造函数
    	vector3[0] = alice;//使用赋值运算符
    	vector3[1] = bob;
    	vector3[2] = cinge;
    	vector3[3] = drag;
    	cout << vector3 << endl;
    
    	//针对拷贝构造函数和赋值运算符，如果是有新的实例对象产生，则使用的是拷贝构造函数，否则就是用的是赋值运算符
    	system("pause");
    	return 0;
    }