第十八章 34用重载输入运算符函数实现字符串的输入

// 34用重载输入运算符函数实现字符串的输入
/*
#include <iostream>
using namespace std;
class String
{
public:
	String(); //默认的构造函数
	String(const char*const ch); //构造带值的string
	int getlen()const { return len;}   //读取长度
	//const char *getstr()const{ return str;} //读取字符串

	//重载输出函数
	friend ostream&operator<<(ostream &o, const String &s)
	{
		o<<s.str;
		return o;
	}
    
	friend istream&operator>>(istream &i, String &s)
	{
		 i>>s.str;
	     return i;
	}

	//这里是可以修改的
	char &operator[](unsigned short int  length);
	char  operator[](unsigned short int  length)const;

	//复制构造函数
	String (const String&r);

	//重载赋值运算符=
	String &operator=(const String &s);
	

private:
	unsigned short int len;
	char *str;
};
//创建一个空的str变量
String::String()
{
    len = 0;
	str = new char[1];
	str[0] = '
 
 
 
  
// 34用重载输入运算符函数实现字符串的输入
/*
#include <iostream>
using namespace std;
class String
{
public:
	String(); //默认的构造函数
	String(const char*const ch); //构造带值的string
	int getlen()const { return len;}   //读取长度
	//const char *getstr()const{ return str;} //读取字符串

	//重载输出函数
	friend ostream&operator<<(ostream &o, const String &s)
	{
		o<<s.str;
		return o;
	}
    
	friend istream&operator>>(istream &i, String &s)
	{
		 i>>s.str;
	     return i;
	}

	//这里是可以修改的
	char &operator[](unsigned short int  length);
	char  operator[](unsigned short int  length)const;

	//复制构造函数
	String (const String&r);

	//重载赋值运算符=
	String &operator=(const String &s);
	

private:
	unsigned short int len;
	char *str;
};
//创建一个空的str变量
String::String()
{
    len = 0;
	str = new char[1];
	str[0] = '\0';
};
String::String(const char*const ch)
{
	cout<<"带一个参数的构造函数"<<endl;
	len = strlen(ch);
	str = new char[len+1];
	for(int i=0; i<len; i++){
	   str[i] = ch[i];
	}
	str[len] = '\0';
};

char & String::operator[](unsigned short int length)
{
	    if(length > len){
		   return str[len-1]; //返回可见字符的值
		}else{
		   return str[length];
		}
};

char String::operator[](unsigned short int length)const
{
	    cout<<"下标运算符const执行"<<endl;
		if(length > len){
		   return str[len-1]; //返回可见字符的值
		}else{
		   return str[length];
		}
};

String::String (const String&rs)
{
	len = rs.getlen();
	str = new char[len+1];
	for(int i=0; i<len; i++){
	    str[i] = rs[i]; 
		//这里因为我们构造一个新对象并且用旧对象来为它赋值，很明显，不会修改旧对象的值，所以旧对象rs在调用operator[]const函数的时候，不用将指定字符串的地址返回，只需要要按值返回这个字符即可
		//第二次重载的operator[]运算符函数，按值返回的一个字符，同时在函数体前面加了一个const
		//表示该函数可以操作const对象，也就是rs
		//这样由于2个同名的函数，它的类型不同，一个可操作const对象，一个不可以，这样就可以做到了对函数的重载
	}
	str[len]='\0';
	cout<<"复制构造函数完成:"<<str<<endl;

};

String& String::operator=(const String &s)
{
	cout<<"operator=执行"<<endl;
	if(this == &s)
	{
	    return *this;
	}else{
	    delete []str; //删除左边的字符串
		len = s.getlen();
		str = new char[len+1];
		for(int i=0; i<len; i++){
		    str[i] = s[i];
		}
		str[len] = '\0';
	}
	return *this; //注意按引用返回，也就是别名
}

int main()
{
    String s;
	cin>>s;
	cout<<s<<endl;
    return 0;
}*/
 
 
 
 
　　
 
  
  

';
};
String::String(const char*const ch)
{
	cout<<"带一个参数的构造函数"<<endl;
	len = strlen(ch);
	str = new char[len+1];
	for(int i=0; i<len; i++){
	   str[i] = ch[i];
	}
	str[len] = '
 
 
 
  
// 34用重载输入运算符函数实现字符串的输入
/*
#include <iostream>
using namespace std;
class String
{
public:
	String(); //默认的构造函数
	String(const char*const ch); //构造带值的string
	int getlen()const { return len;}   //读取长度
	//const char *getstr()const{ return str;} //读取字符串

	//重载输出函数
	friend ostream&operator<<(ostream &o, const String &s)
	{
		o<<s.str;
		return o;
	}
    
	friend istream&operator>>(istream &i, String &s)
	{
		 i>>s.str;
	     return i;
	}

	//这里是可以修改的
	char &operator[](unsigned short int  length);
	char  operator[](unsigned short int  length)const;

	//复制构造函数
	String (const String&r);

	//重载赋值运算符=
	String &operator=(const String &s);
	

private:
	unsigned short int len;
	char *str;
};
//创建一个空的str变量
String::String()
{
    len = 0;
	str = new char[1];
	str[0] = '\0';
};
String::String(const char*const ch)
{
	cout<<"带一个参数的构造函数"<<endl;
	len = strlen(ch);
	str = new char[len+1];
	for(int i=0; i<len; i++){
	   str[i] = ch[i];
	}
	str[len] = '\0';
};

char & String::operator[](unsigned short int length)
{
	    if(length > len){
		   return str[len-1]; //返回可见字符的值
		}else{
		   return str[length];
		}
};

char String::operator[](unsigned short int length)const
{
	    cout<<"下标运算符const执行"<<endl;
		if(length > len){
		   return str[len-1]; //返回可见字符的值
		}else{
		   return str[length];
		}
};

String::String (const String&rs)
{
	len = rs.getlen();
	str = new char[len+1];
	for(int i=0; i<len; i++){
	    str[i] = rs[i]; 
		//这里因为我们构造一个新对象并且用旧对象来为它赋值，很明显，不会修改旧对象的值，所以旧对象rs在调用operator[]const函数的时候，不用将指定字符串的地址返回，只需要要按值返回这个字符即可
		//第二次重载的operator[]运算符函数，按值返回的一个字符，同时在函数体前面加了一个const
		//表示该函数可以操作const对象，也就是rs
		//这样由于2个同名的函数，它的类型不同，一个可操作const对象，一个不可以，这样就可以做到了对函数的重载
	}
	str[len]='\0';
	cout<<"复制构造函数完成:"<<str<<endl;

};

String& String::operator=(const String &s)
{
	cout<<"operator=执行"<<endl;
	if(this == &s)
	{
	    return *this;
	}else{
	    delete []str; //删除左边的字符串
		len = s.getlen();
		str = new char[len+1];
		for(int i=0; i<len; i++){
		    str[i] = s[i];
		}
		str[len] = '\0';
	}
	return *this; //注意按引用返回，也就是别名
}

int main()
{
    String s;
	cin>>s;
	cout<<s<<endl;
    return 0;
}*/
 
 
 
 
　　
 
  
  

';
};

char & String::operator[](unsigned short int length)
{
	    if(length > len){
		   return str[len-1]; //返回可见字符的值
		}else{
		   return str[length];
		}
};

char String::operator[](unsigned short int length)const
{
	    cout<<"下标运算符const执行"<<endl;
		if(length > len){
		   return str[len-1]; //返回可见字符的值
		}else{
		   return str[length];
		}
};

String::String (const String&rs)
{
	len = rs.getlen();
	str = new char[len+1];
	for(int i=0; i<len; i++){
	    str[i] = rs[i]; 
		//这里因为我们构造一个新对象并且用旧对象来为它赋值，很明显，不会修改旧对象的值，所以旧对象rs在调用operator[]const函数的时候，不用将指定字符串的地址返回，只需要要按值返回这个字符即可
		//第二次重载的operator[]运算符函数，按值返回的一个字符，同时在函数体前面加了一个const
		//表示该函数可以操作const对象，也就是rs
		//这样由于2个同名的函数，它的类型不同，一个可操作const对象，一个不可以，这样就可以做到了对函数的重载
	}
	str[len]='
 
 
 
  
// 34用重载输入运算符函数实现字符串的输入
/*
#include <iostream>
using namespace std;
class String
{
public:
	String(); //默认的构造函数
	String(const char*const ch); //构造带值的string
	int getlen()const { return len;}   //读取长度
	//const char *getstr()const{ return str;} //读取字符串

	//重载输出函数
	friend ostream&operator<<(ostream &o, const String &s)
	{
		o<<s.str;
		return o;
	}
    
	friend istream&operator>>(istream &i, String &s)
	{
		 i>>s.str;
	     return i;
	}

	//这里是可以修改的
	char &operator[](unsigned short int  length);
	char  operator[](unsigned short int  length)const;

	//复制构造函数
	String (const String&r);

	//重载赋值运算符=
	String &operator=(const String &s);
	

private:
	unsigned short int len;
	char *str;
};
//创建一个空的str变量
String::String()
{
    len = 0;
	str = new char[1];
	str[0] = '\0';
};
String::String(const char*const ch)
{
	cout<<"带一个参数的构造函数"<<endl;
	len = strlen(ch);
	str = new char[len+1];
	for(int i=0; i<len; i++){
	   str[i] = ch[i];
	}
	str[len] = '\0';
};

char & String::operator[](unsigned short int length)
{
	    if(length > len){
		   return str[len-1]; //返回可见字符的值
		}else{
		   return str[length];
		}
};

char String::operator[](unsigned short int length)const
{
	    cout<<"下标运算符const执行"<<endl;
		if(length > len){
		   return str[len-1]; //返回可见字符的值
		}else{
		   return str[length];
		}
};

String::String (const String&rs)
{
	len = rs.getlen();
	str = new char[len+1];
	for(int i=0; i<len; i++){
	    str[i] = rs[i]; 
		//这里因为我们构造一个新对象并且用旧对象来为它赋值，很明显，不会修改旧对象的值，所以旧对象rs在调用operator[]const函数的时候，不用将指定字符串的地址返回，只需要要按值返回这个字符即可
		//第二次重载的operator[]运算符函数，按值返回的一个字符，同时在函数体前面加了一个const
		//表示该函数可以操作const对象，也就是rs
		//这样由于2个同名的函数，它的类型不同，一个可操作const对象，一个不可以，这样就可以做到了对函数的重载
	}
	str[len]='\0';
	cout<<"复制构造函数完成:"<<str<<endl;

};

String& String::operator=(const String &s)
{
	cout<<"operator=执行"<<endl;
	if(this == &s)
	{
	    return *this;
	}else{
	    delete []str; //删除左边的字符串
		len = s.getlen();
		str = new char[len+1];
		for(int i=0; i<len; i++){
		    str[i] = s[i];
		}
		str[len] = '\0';
	}
	return *this; //注意按引用返回，也就是别名
}

int main()
{
    String s;
	cin>>s;
	cout<<s<<endl;
    return 0;
}*/
 
 
 
 
　　
 
  
  

';
	cout<<"复制构造函数完成:"<<str<<endl;

};

String& String::operator=(const String &s)
{
	cout<<"operator=执行"<<endl;
	if(this == &s)
	{
	    return *this;
	}else{
	    delete []str; //删除左边的字符串
		len = s.getlen();
		str = new char[len+1];
		for(int i=0; i<len; i++){
		    str[i] = s[i];
		}
		str[len] = '
 
 
 
  
// 34用重载输入运算符函数实现字符串的输入
/*
#include <iostream>
using namespace std;
class String
{
public:
	String(); //默认的构造函数
	String(const char*const ch); //构造带值的string
	int getlen()const { return len;}   //读取长度
	//const char *getstr()const{ return str;} //读取字符串

	//重载输出函数
	friend ostream&operator<<(ostream &o, const String &s)
	{
		o<<s.str;
		return o;
	}
    
	friend istream&operator>>(istream &i, String &s)
	{
		 i>>s.str;
	     return i;
	}

	//这里是可以修改的
	char &operator[](unsigned short int  length);
	char  operator[](unsigned short int  length)const;

	//复制构造函数
	String (const String&r);

	//重载赋值运算符=
	String &operator=(const String &s);
	

private:
	unsigned short int len;
	char *str;
};
//创建一个空的str变量
String::String()
{
    len = 0;
	str = new char[1];
	str[0] = '\0';
};
String::String(const char*const ch)
{
	cout<<"带一个参数的构造函数"<<endl;
	len = strlen(ch);
	str = new char[len+1];
	for(int i=0; i<len; i++){
	   str[i] = ch[i];
	}
	str[len] = '\0';
};

char & String::operator[](unsigned short int length)
{
	    if(length > len){
		   return str[len-1]; //返回可见字符的值
		}else{
		   return str[length];
		}
};

char String::operator[](unsigned short int length)const
{
	    cout<<"下标运算符const执行"<<endl;
		if(length > len){
		   return str[len-1]; //返回可见字符的值
		}else{
		   return str[length];
		}
};

String::String (const String&rs)
{
	len = rs.getlen();
	str = new char[len+1];
	for(int i=0; i<len; i++){
	    str[i] = rs[i]; 
		//这里因为我们构造一个新对象并且用旧对象来为它赋值，很明显，不会修改旧对象的值，所以旧对象rs在调用operator[]const函数的时候，不用将指定字符串的地址返回，只需要要按值返回这个字符即可
		//第二次重载的operator[]运算符函数，按值返回的一个字符，同时在函数体前面加了一个const
		//表示该函数可以操作const对象，也就是rs
		//这样由于2个同名的函数，它的类型不同，一个可操作const对象，一个不可以，这样就可以做到了对函数的重载
	}
	str[len]='\0';
	cout<<"复制构造函数完成:"<<str<<endl;

};

String& String::operator=(const String &s)
{
	cout<<"operator=执行"<<endl;
	if(this == &s)
	{
	    return *this;
	}else{
	    delete []str; //删除左边的字符串
		len = s.getlen();
		str = new char[len+1];
		for(int i=0; i<len; i++){
		    str[i] = s[i];
		}
		str[len] = '\0';
	}
	return *this; //注意按引用返回，也就是别名
}

int main()
{
    String s;
	cin>>s;
	cout<<s<<endl;
    return 0;
}*/
 
 
 
 
　　
 
  
  

';
	}
	return *this; //注意按引用返回，也就是别名
}

int main()
{
    String s;
	cin>>s;
	cout<<s<<endl;
    return 0;
}*/
// 34用重载输入运算符函数实现字符串的输入
/*
#include <ios