第十八章 31用复制构造函数实现字符串的初始化

//31用复制构造函数实现字符串的初始化
/*
#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;} //读取字符串


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

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

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;

};
int main()
{
	String str;
	cout<<str.getstr()<<endl;
	cout<<"str:"<<str.getlen()<<endl;

	String s1("hello word");
	//cout<<s1.getlen()<<endl;
	cout<<s1.getstr()<<endl;
	cout<<"s1:"<<s1.getlen()<<endl;

	char*temp = "help me";
	String s3(temp);
	cout<<s3.getstr()<<endl;
	cout<<"s3:"<<s3.getlen()<<endl;
	
	//越界的值
	cout<<"越界的值"<<endl;
	cin>>s3[999];
	cout<<s3.getstr()<<endl;
	cout<<"s3:"<<s3.getlen()<<endl;
	cout<<"s3[999]:"<<s3[999]<<endl;
	cout<<s3.getstr()<<endl;

    cout<<"调用复制构造函数"<<endl;
	String s4 = s3; //调用复制构造函数
	cout<<"s4:"<<s4.getstr()<<endl;
	cout<<"s4:"<<s4.getlen()<<endl;

    return 0;
}*/

/*
#include <iostream>
using namespace std;
class A
{
public: 
	A(int i, int j){ x=i; y=j;}
	void set(int s1, int s2){ x=s1; y=s2;}
	void print(){cout<<x<<endl;}
	void print()const { cout<<y<<endl;
	   //set(1,2); 在const函数内不能调用未const函数
	}
private:
	int x, y;
};
int main()
{
	const A a(2,3); //常量对像
	a.print();
	//a.set(22,33); //常量对像不可修改

	A b(4,5);
	b.print();
	b.set(44,55);
	b.print();

	//总结
	//const对像只能调用const成员函数，并且const对像的值不能被修改，只有const成员函数才有资格操作const对像，没有使用const关键字修饰的成员函数不能用来操作const对像
	//另外我们还需要认识到:
	//const不光可以定义常量，而且可用来修饰函数的参数，返回值，甚至函数定义体
	//const修饰函数参数，表示函数参数不可更改
	//const修改函数返咽值，表示返回值不可改变
	//const修饰函数的定义体，表示函数体内就不能修改对像的何意成员
	//在const成员函数体内试图修改const对像的数据成员的值将会产生语法错误
	//而且在const函数体中调用非const成员函数也会产生语法错误

	//这样做对基类很有用，我们知道基类的成员函数可以被派生类继承并覆盖，那么假如我们将基类的成员函数前加修饰符const的话，可防止派生类的覆盖函数改变数据成员的值


    return 0;
}*/