自定义模板练习

内容

设计一个容器，可以用来存储不同的类型数据

首先创建一个类：Vector类

[代码] Vector.h

#pragma once
#include <iostream>

template <typename T>
class Vector
{
public:
	Vector(int size=10);
	Vector(const Vector &vector);
	~Vector();
	int getSize();

	T &operator [](int index);
	Vector operator =(const Vector &vector);

	template <typename T>
	friend std::ostream &operator<< (std::ostream &os, const Vector<T> &vector);


private:
	T *m_base;
	int m_len;
};

[代码] Vector.cpp

#include "Vector.h"

template<typename T>
Vector<T>::Vector(int size)
{
	if (size > 0) {
		m_len = size;
		m_base = new T[size];		//m_base = new Student[2]
	}
}

template<typename T>
Vector<T>::Vector(const Vector & vector)
{
	m_len = vector.m_len;
	m_base = new T[m_len];

	for (int i = 0; i < m_len; i++) {
		m_base[i] = vector.m_base[i];
	}
}

template<typename T>
Vector<T>::~Vector()
{
	delete[] m_base;
	std::cout << "调用模板析构函数" << std::endl;
}

template<typename T>
int Vector<T>::getSize()
{
	return m_len;
}

template <typename T>
T &Vector<T>::operator[](int index)
{
	return m_base[index];
}

template <typename T>
Vector<T> Vector<T>::operator=(const Vector & vector)
{
	if (vector.m_len > 0) {
		delete m_base;
		m_len = 0;
	}
	m_len = vector.m_len;
	m_base = new T[m_len];

	for (int i = 0; i < m_len; i++) {
		m_base[i] = vector.m_base[i];
	}

	return *this;
}


template <typename T>
std::ostream & operator<<(std::ostream & os, const Vector<T> & vector)
{
	for (int i = 0; i < vector.m_len; i++) {
		os << vector.m_base[i] << " ";
	}
	os << std::endl;

	return os;
}

[代码] main.cpp

#include "Vector.cpp"

class Student {
public:
	Student() {
		age = 0;
		name = NULL;
	}
	Student(const char *name, int age) {
		int len = strlen(name) + 1;
		this->name = new char[len];
		strcpy_s(this->name, len, name);
		this->age = age;
	}

	Student(const Student &stu) {
		int len = strlen(stu.name) + 1;
		this->name = new char[len];
		strcpy_s(this->name, len, stu.name);
		this->age = stu.age;
	}

	~Student() {
		std::cout << "调用Student析构函数" << std::endl;
		delete[] name;
//		name = NULL;
	}
	friend std::ostream & operator<<(std::ostream & os, const Student & stu);

	Student operator =(const Student &stu) {
		
		name = new char[strlen(stu.name)+1];
		strcpy_s(name, strlen(stu.name)+1, stu.name);
		age = stu.age;

		return stu;
	}

private:
	char *name;
	int age;
};

std::ostream & operator<<(std::ostream & os, const Student & stu) {
	os << "姓名:" << stu.name 
		<< " 年龄:" << stu.age;

	return os;
}

int main() {
	/*Vector<int> v1(10);

	for (int i = 0; i < v1.getSize(); i++) {
		v1[i] = i;
	}

	std::cout << "-------V1--------\n" << v1 << std::endl;

	Vector<int> v2(v1);
	std::cout << "-------V2--------\n" << v2 << std::endl;

	Vector<int> v3(20);
	v3 = v1;

	std::cout << "-------V3--------\n" << v3 << std::endl;*/

	Student stu1("小花", 18);
	Student stu2("小美", 20);

	Vector<Student> student(2);
	student[0] = stu1;
	student[1] = stu2;

	/*for (int i = 0; i < student.getSize(); i++) {
		std::cout << student[i] << std::endl;
	}*/

	std::cout << "-------student --------\n" << student << std::endl;
	
	return 0;
}

总结

在main.cpp中创建了一个学生类，重写了赋值运算符，没有重写拷贝构造函数。
因为赋值构造函数是返回的Student类型，return过程中是会调用拷贝构造函数
解决方法：
1、重写拷贝构造函数
2、重写的赋值运算符返回引用类型