//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;
}*/