String 的 operator 运算符重载

重载函数：同一作用域，同名不带形参的函数集。
重载运算符：
  1、运算符只能针对基本类型
  2、重载运算符拓展对复杂类型进行运算:重载运算符函数
   <返回类型> operator<运算符>(形参列表)
     {
     } 
  3、运算符：sizeof, ::  * -> .不能重载
  4、顺序性，结合性，数目不能改变

C++的堆区申请：
  1、new 运算符。用于申请堆区空间，必须由delete来释放
  2、分配空间：
       １、一个变量空间
        　      new 类型     new char(字符值)     delete 地址
        2、一个对象空间
                  new 类名(实参列表);           delete 对象地址
        3、一块空间：（数组）  int[];
                  new 类型[长度]；           delete[] 首地址

 

     重载 string 类的 []  ,<  , > ,  <<  

#include
#include
using namespace std;

class stringlf
{
//方法
public:
	//构造器
	stringlf();
	stringlf(const char*);
	stringlf(const stringlf&);//值传递
	//析构函数
	~stringlf();	//不能重载,无参数
	//重载运算符:重载函数
	char& operator[](int index);	//s.operator[](2)
	//获取私有数据的接口
	const char* c_str();
	//接口:获取对象里面的长度
	unsigned short length()const;
	bool operator<(const stringlf&);
	bool operator>(const stringlf&);
//属性
private:
	char* str;
};

//拷贝构造
stringlf::stringlf(const stringlf& s)
{
	//*this=s;
	this->str=new char[s.length()+1];
	if(NULL==this->str)
		this->str=NULL;
	memcpy(this->str,s.str,s.length()*sizeof(char));
}

stringlf::stringlf()
{
	this->str=new char('\0');
	if(NULL==this->str)
		this->str=NULL;
}

stringlf::stringlf(const char* str)
{
	unsigned short ilen=strlen(str);
	this->str=new char[ilen+1];
	if(NULL==this->str)
		this->str=NULL;
	else
	memcpy(this->str,str,sizeof(char)*ilen);
}

bool stringlf::operator<(const stringlf& s)
{
	if(strcmp(this->str,s.str)<0)
		return true;
	else
		return false;
}

bool stringlf::operator>(const stringlf& s)
{
	if(strcmp(this->str,s.str)>0)
		return true;
	else
		return false;
}

stringlf::~stringlf()
{
	if(NULL!=this->str)
	{
		delete[] this->str;
	}
}

//重载输出
ostream& operator<<(ostream& output,stringlf& s)
{
	output<>(istream& input,stringlf& s)
{
    input>>s.c_str();
    return input;
}

//重载运算符:
char& stringlf::operator[](int index)
{
	return this->str[index];
}

const char* stringlf::c_str()
{
	return this->str;
}

//求字符串的长度
unsigned short stringlf::length()const
{
//字符串:  \0 作为结束字符
	unsigned short ilen=0;
	while(NULL!=this->str && this->str[ilen++]!='\0');
	return ilen;
}

int main()
{
//	stringlf s1=stringlf("abcdef");//有参构造
//	stringlf s2(s1);//stringlf s2=s1;

//string : 字符串类(数据,方法)
	stringlf s;//无参（默认）
	stringlf s1("abcde");//有参构造

	cout<=s2"<s2)
		cout<<"s1>s2"<>s1;
    cout<

 

    重载 string 的  +  

#include
#include

using namespace std;

class String
{
public:
	String();
	String(const char* p);
	String(const String& s);//拷贝构造
	//接口:
	const char* c_str() const;
	short length()const;//求该对象的长度
	String operator+(String&);
	void show()
	{
		cout<str<str=new char('\0');
	//*this->str='\0';
}

String::String(const char* p)
{
//分配数组空间:malloc（长度）'\0'
	int ilen=strlen(p);
	this->str=new char[ilen+1];
	if(NULL!=this->str)
	{
		memcpy(this->str,p,ilen+1);//sizeof 类型 空间长度 strlen(元素)
	}
}

//拷贝构造
String::String(const String& s)
{
	cout<<"String(String&)"<str=new char[s.length()+1];
	{
		memcpy(this->str,s.str,s.length()+1);
	}
}

//返回数组首地址,常方法(只读取内容,不能修改内容)
const char* String::c_str() const
{
	//this->str="abcd";	//不能修改
	//this->str[0]='A';	//修改的是str指向的内容
	this->str[0]='1';
	return this->str;
}

//全局:
void show(String s)	//引用:区别名(变量的别名) int &a =i；
{
	cout<str!=NULL&&this->str[ilen++]!='\0');
	return ilen;
}

String String::operator+(String& s)
{
	//实例化对象:有参构造
	String result;//分配空间
	if(!result.str)
	{
		delete[] result.str;
	}
	result.str=new char[this->length()+s.length()+1];
	memcpy(result.str,this->str,this->length());
	memcpy(result.str+this->length()-1,s.str,s.length());
	return result;
}

int main()
{
//实例化
	String s("abcde");
	String s1("1234");

	String s2=s+s1;//  s.operator+(s1)
	s2.show();

	//重载运算符:重载函数

//	char buf[100]="abd";

//	String s2;
//	s2=s1;

/*
//实例化 构造器:分配空间并初始化
	String s;		//方法与形参
	String s1("abcdef");	//有参构造
	String s2=String("abcde");//String s2(String("abdef"));	//int a=3;
*/

/*
	//常对象
	const String s2("lifei");//只读空间
	//无名对象:直接调用构造方法
	cout<