数组模板类（数组元素是int,char,Teacher(类对象)）(类对象的输出重载左移运算符问题未解决)

myVector_test.cpp// myVector_test.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include<iostream>
#include<cstring>
using namespace std;

#include "myVector.cpp"

//1 优化Teacher类，属性变成 char *pname,购置函数里面分配内存
//2 优化Teacher类，析构函数释放pname指向的内存空间
//3 优化Teacher类，避免浅拷贝 重载= 重写拷贝构造函数
//4 优化Teacher类，在Teacher增加<<
//5 在模板数组类中，存int char Teacher Teacher*
//====>容器的概念

class Teacher
{
public:
Teacher()
{
age = 30;
strcpy(name, "");//初始化为一个空串，年龄的默认值是30
}
Teacher(char *name, int age)
{
this->age = age;
strcpy(this->name, name);
}
void printTeacher()
{
cout << "name:" << name << " " << "age:" << age << endl;
}
int getAge()
{
return age;
}
char* getName()
{
return name;
}
private:
int age;
char name[30];
};

int main()
{
//3.Teacher类型的数组（Teacher是一个复杂数据类型)
Teacher t1("Rita",10 ), t2("Zhang",20 ), t3("Wang",30 ), t4("Li",40 );
myVector<Teacher> tArray(4); //定义了一个Teacher类型的数组
tArray[0] = t1;
tArray[1] = t2;
tArray[2] = t3;
tArray[3] = t4;
for (int i = 0; i < 4; i++)
{
Teacher tmp = tArray[i];
tmp.printTeacher();
}

//报错：二进制“<<”: 没有找到接受“Teacher”类型的右操作数的运算符(或没有可接受的转换)
//cout << tArray;
//原因：当时int类型的数组类时，成员变量是int类型的，是基本数据类型，
//所以重载之后可直接输出int类型的值，但是Teacher是一个复杂数据类型，
//要输出的时候，你要将Teacher中的age和name一起输出，在一起就不是基本数据类型了，
//所以要再重载一次 << 操作符

//1.int 类型的数组
myVector<int>	myv1(10);//初始化,相当于定义了一个长度为10的int类型的数组
//为数组赋值
for (int i = 0; i < myv1.getLen(); ++i)
{
myv1[i] = i;
cout << myv1[i] << " ";//报错：没有与这些操作数匹配的[]运算符，因为myv1不是基本数据类型，是一个int数组类，所以要重载[]
}
cout << endl;

myVector<int>	myv2 = myv1;//用myv1初始化myv2（区分赋值和初始化，是两个不一样的概念，赋值不会调用类的拷贝构造函数），会调用拷贝构造函数，会发生浅拷贝,所以要手动实现拷贝构造函数
//for (int i = 0; i < myv2.getLen(); ++i)
//{
//	cout << myv2[i] << " ";
//}
//cout << endl;
cout<<myv2;//因为myv2不是基本数据类型，所以要重载<<

//2.char类型的数组
myVector<char>	myv3(4);//相当于定义了一个长度为10的char类型的数组，会调用构造函数，对类的属性进行初始化（m_space和m_len都要初始化）
//向数组里面写值
myv3[0] = 'R';//[]已经重载过了，可以直接用
myv3[1] = 'i';
myv3[2] = 't';
myv3[3] = 'a';
cout << myv3;//<<已经重载过了，可以直接用

system("pause");
return 0;
}

myVector.h#pragma once
#include<iostream>
using namespace std;
//数组模板类
//因为是数组模板类，所以要加template <typename T>
//重载<< 友元函数（非成员函数）friend osream& operator<<(ostream& out,const myVector& obj)
//构造函数，设置默认参数
//拷贝构造函数，避免浅拷贝问题 （因为此数组类中有指针）
//析构函数
//重载[] 注意返回值类型是T （因为可能是int类型的数组，也可能是char类型的数组，也有可能是Teacher类型的数组）
//重载= a3=a2 返回值是一个引用 myVector& operator=(const myVector &obj)
//成员函数 int getLen()
//属性（protected） int m_len;T *m_space;

template <typename T>
class myVector
{
friend ostream& operator<< <T>(ostream& out, const myVector& obj);
//friend ostream& operator<< <T>(ostream& out, myVector& obj);

public:
myVector(int size=0);//构造函数
int getLen();//普通成员函数，返回m_len
myVector(const myVector& obj);//拷贝构造函数
~myVector();//析构函数
public://重载
T& operator[](int index);
T& operator=(const T& obj);
protected:
int m_len;
T *m_space;
};

myVector.cpp#include "myVector.h"
#include<iostream>
using namespace std;

template<typename T>//模板类一定要加上这句话，否则会报错，每一个成员函数都要加
myVector<T>::myVector(int size)//myVector<T>:: 一定不要忘了加<T>
{
m_space = new T[size];//一定不要忘了初始化的时候为数组分配内存空间，不要只初始化了长度，只有长度没有空间你为数组赋值的时候你要把这些值写在哪里啊！不写这句话就执行数组赋值会发生中断
m_len = size;
}

template<typename T>
int myVector<T>::getLen()
{
return m_len;
}

template<typename T>
T& myVector<T>::operator[](int index)
{
return m_space[index];
}
template<typename T>//功能：输出基本数据类型的数组
ostream& operator<<(ostream& out, const myVector<T>& obj)
{
for (int i = 0; i < obj.m_len; i++)
{
out << obj.m_space[i] << " ";
}
out << endl;
return out;
}

//MyVector<int> myv2 = myv1;
template<typename T>
myVector<T>::myVector(const myVector& obj)
{
//1.根据myv1大小为myv2分配内存2.copy数据
m_len = obj.m_len;
m_space = new T[m_len];

for (int i = 0; i < m_len; ++i)
{
m_space[i] = obj.m_space[i];
}
}
template<typename T>
myVector<T>::~myVector()
{
if (m_space != NULL)
{
delete[]m_space;
m_space = NULL;
m_len = 0;
}
}
//template<typename T>////功能：输出复杂(Teacher)数据类型的数组
//ostream& operator<<(ostream& out, myVector<T>& obj)
//{
// for (int i = 0; i < obj.m_len; i++)
// {
// out << obj->m_space[i].name[] << "+" << obj->m_space[i].age << " ";
// }
// out << endl;
// return out;
//}