define class

TString.h

#ifndef TSTRING_H
#define TSTRING_H
#include <iostream>
#include <cstdlib>

//类的编译，先处理成员变量，后处理函数，所以不用太在意成员变量与成员函数的顺序。
class TString {

	//集中在头部声明较好
	//friend函数是否受public,private影响
	//这算friend函数的声明么(只是说明了访问权限)
	friend TString operator+(const TString &t1, const TString &t2);

	//必须是friend函数
	//第一个参数类型
	//第一个参数const可以么
	//第一个参数可以不是引用么	
	friend std::ostream& operator<<(std::ostream& outs, const TString& t);
	friend std::istream& operator>>(std::istream& ins, TString & t);
public:
	//什么时候必须为虚函数
	//析构函数中释放成员变量么
	//private可以么，会怎样
	//重载可否
	~TString();

	//private可以么
	//const可以么
	//virtual 可以么
	TString();

	//声明为explict会怎样
	TString(const char* t);

	//为什么是引用
	//为什么const
	//explict？
	TString(const TString& t);

	//操作符重载为成员函数，实际的第一个参数？
	TString& operator=(const TString& t);
	TString& operator=(const char* t);

	//声明定义都要有const
	//const函数需要修改变量
	const char& operator[](int index) const;
	char& operator[](int index);//为什么两种[]

								//声明定义都要有么
								//实现放在哪个文件
	inline int size() const;

	//const 函数返回的非常量引用或指针会怎样
	char *getData() const;
private:
	char* mData;
};

//inline 写在实现处较好
//inline 函数必须和定义在一个文件
inline int TString::size() const {
	return strlen(mData);
}

#endif//TSTRING_H

TString.cpp

#include "TString.h"
using namespace std;

TString::~TString() {
	delete[] mData;//如何删除
	mData = nullptr;//安全
}

TString::TString() {
	mData = new char[1];
	mData[0] = '\0';
}

TString::TString(const char* t) {
	if (!t) {
		mData = new char[1];
		mData[0] = '\0';
	}
	else {
		auto len = strlen(t) + 1;
		mData = new char[len];
		memcpy(mData, t,len);
	}
}

TString::TString(const TString& t) {
	auto len = t.size() + 1;
	mData = new char[len];
	memcpy(mData, t.getData(),len);
}

TString& TString::operator=(const char* t) {
	delete[] mData;

	auto len = strlen(t) + 1;

	mData = new char[len];
	if (mData) {
		memcpy(mData, t,len);
	}
	else {
		mData[0] = '\0';
	}
	return *this;
}

TString& TString::operator=(const TString& t) {
	if (this == &t) {//自赋值检查
		return *this;
	}

	delete[] mData;//释放已有资源

	auto len = t.size() + 1;
	mData = new char[len];
	memcpy(mData, t.getData(),len);

	return *this;
}

//const 函数返回的指针或引用，自动变为const
char* TString::getData() const {
	return mData;
}

char& TString::operator[](int index) {
	return *(mData + index);
}

const char & TString::operator[](int index) const {
	return *(mData + index);
}


TString operator+(const TString &t1, const TString &t2) {
	int len = t1.size() + t2.size() + 1;
	char* data = new char[len];
	memcpy(data, t1.getData(), t1.size());
	memcpy(data + t1.size(), t2.getData(), t2.size() + 1);
	return TString(data);
}


std::ostream& operator<<(std::ostream& outs, const TString& t) {
	outs << t.getData();
	return outs;
}

std::istream& operator>>(std::istream& ins, TString& t) {
	char* buff = new char[1024];
	ins >> buff;
	t.mData = buff; //访问私有成员
	return ins;
}

#include "TString.h"
using namespace std;

int main() {

	TString t1;
	cout << t1.size() << endl;

	TString t2("foo");
	TString t3 = "bar";

	TString t5(t3);
	TString t4 = t3;

	t4 = t2;

	TString t6 = t2 + t3;
	
	cout << t6<<endl;
	cout << t6.size();
	cout << t3;
	cin >> t4;
	cout << t4;
	
	char c;
	std::cin >> std::noskipws >> c;
	return 0;
}