string复制给char*_字符串（一）---重写string

#define _CRT_SECURE_NO_WARNINGS//忽视警告（strlenf等函数为老式写法）
#include <iostream>
using namespace std;
class String
{
public:
	String();//只定义String类对象，不初始化时用的构造函数
	String(const char* str);//定义并初始化时用的构造
	String(const String& str);//拷贝构造
	String& operator=(const String& str);//赋值函数,不定义也行
                        //类本就有默认"=",可以完成一个对象赋值给另一个对象
	~String();//析构函数
        //重载<<,使输出时直接输出成员变量m_data;
	friend std::ostream& operator <<(std::ostream& out, const String& s);
        //重载+，使两个String类对象可以相加。返回值不能为引用
	friend String operator +(const String& s1, const String& s2);
        //重载+，使String类对象可以和字符数组相加。返回值不能为引用
	friend String operator +(const String& s1, const char* s2);
        //重载[],必须定义为成员函数
        char operator[](int id);
        //重载==
	bool operator==(const String& s);
	char* m_data;
	int length;
};
String::String()
{
	m_data = new char[1];
	m_data[0] = '0';
	length = 0;
}
String::String(const char* str)//以字符数组初始化String类对象
{
	length = strlen(str);
	m_data = new char[length + 1];//求长度的strlen不计算'0'
	strcpy(m_data, str);//字符复制会复制‘0’,故m_data要开辟足够空间
}
String::String(const String& str)//拷贝构造函数
{
	length = strlen(str.m_data);
	m_data = new char[length + 1];
	strcpy(m_data, str.m_data);
}
String& String::operator=(const String &str)
{
	if (this == &str)
	{//为了防止B=B时，直接把B给释放了，然后再赋值也没用了
		return *this;
	}
	//B=A,则B之前的数据不要了，要手动释放。
	delete[]m_data;
	length = strlen(str.m_data);
	m_data = new char[length + 1];
	strcpy(m_data, str.m_data);
	return *this;
}
String::~String()
{
	delete[]m_data;
	m_data = NULL;
}
std::ostream& operator <<(std::ostream& out, const String& s)
{
	out << s.m_data;//out在这里就是cout,因为cout也只是ostream类的一个对象而已
	return out;
}
//重载+，实现两个String对象可以相加
String operator +(const String& s1, const String& s2)
{
	String kid_string;
	int len = strlen(s1.m_data) + strlen(s2.m_data);
	kid_string.m_data = new char[len + 1];
	for (int i = 0; i < strlen(s1.m_data); i++)
		kid_string.m_data[i] = s1.m_data[i];
	for (int i = strlen(s1.m_data); i < len; i++)
		kid_string.m_data[i] = s2.m_data[i - strlen(s1.m_data)];//将s赋值给str后半段
	kid_string.m_data[len] = '0';
	kid_string.length = len;
	return kid_string;//kidstring是局部变量，返回值如果是kinstring的引用，operator+函数
         //一结束完成就死了。无法继续赋值运算符的计算。
         //故不能返回引用
}
String operator +(const String& s1, const char* s2)
{
	String kid_string;
	int len = strlen(s1.m_data) + strlen(s2);
	kid_string.m_data = new char[len + 1];
	for (int i = 0; i < strlen(s1.m_data); i++)
		kid_string.m_data[i] = s1.m_data[i];
	for (int i = strlen(s1.m_data); i < len; i++)
		kid_string.m_data[i] = s2[i - strlen(s1.m_data)];
	kid_string.m_data[len] = '0';
	kid_string.length = len;
	return kid_string;
}
char String::operator[](int id)
{
	return this->m_data[id];
}
bool String::operator==(const String& s)//传入一般都使用引用，速度快
{
       if(strcmp(m_data,s.m_data)==0)
           return true;
       else
           return false;
}