-
拷贝构造
#include <iostream>
#include <string.h>
using namespace std;
class mystring
{
public:
char *s;
public:
mystring()
{
s = new char[1024];
cout << "mystring" << endl;
}
//拷贝构造
mystring(const mystring &it)
{
s= new char[1024];
memset(s,0,1024);
strcpy(s,it.s);
}
~mystring()
{
cout << "~mystring" << endl;
}
};
int main()
{
mystring str1;
strcpy(str1.s,"hello world");
//这样的方式仅仅调用了一次构造方法
mystring str2 = str1;
// mystring str2;
// str2 = str1; //这个过程不是拷贝构造的过程，仅仅是=号操作
cout << str2.s << endl;
return 0;
}
执行后的效果是：
当把代码改成以下的方式的时候，运行结果例如以下：
#include <iostream>
#include <string.h>
using namespace std;
class mystring
{
public:
char *s;
public:
mystring()
{
s = new char[1024];
cout << "mystring" << endl;
}
//拷贝构造
mystring(const mystring &it)
{
cout << "copy mystring" << endl;
s= new char[1024];
memset(s,0,1024);
strcpy(s,it.s);
}
~mystring()
{
cout << "~mystring" << endl;
delete []s;
}
};
int main()
{
mystring str1;
strcpy(str1.s,"hello world");
//这样的方式仅仅调用了一次构造方法
//mystring str2 = str1;
mystring str2;
str2 = str1; //这个过程不是拷贝构造的过程，仅仅是=号操作
cout << str2.s << endl;
return 0;
}
str1 = str2的本质
2.操作符重载规则
重载操作符函数能够对操作作出新的解释，但原有基本予以不变：
A:不改变操作符的优先级
B:不改变操作符的结合性
C:不改变操作符须要的操作数
D:不能创建新的操作符
成员的语法形式为：
类型 类名：：operator op(參数表)
{
//相对于该类定义的操作
}
重载赋值操作符
赋值操作符重载用于对象数据的复制
operator= 必须重载为成员函数
voidoperator = (const classname &it);
classname &operator = (const classname &it);
返回引用会支持例如以下语法：obj1= obj2 = obj3;
3.操作符重载的案例：
#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;
class mystring
{
public:
char *s;
public:
mystring()
{
s = new char[1024];
cout << "mystring" << endl;
}
mystring(const mystring &it)//深拷贝
{
cout << "copy mystring" << endl;
s = new char[1024];
memset(s, 0, 1024);
strcpy(s, it.s);
}
~mystring()
{
cout << "~mystring" << endl;
delete []s;
}
mystring operator =(const mystring &it)//重载了一个=号操作符
{
cout << "= operator" << endl;
memset(s, 0, 1024);
strcpy(s, it.s);
//在这个过程中调用了深拷贝的过,这里是以个暂时的拷贝过程，拷贝完毕之后调用深拷贝
return *this;
}
mystring operator =(const char *str)//重载了一个=号操作符
{
memset(s, 0, 1024);
strcpy(s, str);
return *this;
}
mystring operator =(int i)//重载了一个=号操作符
{
memset(s, 0, 1024);
sprintf(s, "%d", i);
return *this;
}
mystring operator + (const mystring &it)//重载了一个+号操作符
{
strcat(s, it.s);
return *this;
}
mystring operator + (const char *str)//重载了一个+号操作符
{
strcat(s, str);
return *this;
}
void operator +=(const char *str)//
{
strcat(this->s, str);
}
mystring operator + (int i)//重载了一个+号操作符,一元操作符重载
{
char temp[100] = {0};
sprintf(temp, "%d", i);
strcat(s, temp);
return *this;
}
void operator <<(const char *str)//把<<操作符定义为赋值
{
strcpy(s, str);
}
void operator >>(char *str)//把<<操作符定义为赋值
{
strcpy(str, s);
}
mystring operator ++(int)//重载++操作符的函数int參数是固定
{
int len = strlen(s);
for(int i = 0;i < len; i++)
{
s[i]++;//让s的第一个成员char + 1,就是将s[0]相应字符的ASCII码 + 1
}
return *this;
}
void * operator new(size_t size)//假设重载的new，那么必须重载delete
{
//參数size就是sizeof(mystring)的大小.
cout << "size = " << size << endl;
mystring *p = (mystring *)malloc(size);
return p;
}
void * operator new[](size_t size)//假设重载的new，那么必须重载delete
{
//參数size就是sizeof(mystring)的大小 * new[x] + 4个字节.
cout << "size = " << size << endl;
//mystring *p = (mystring *)malloc(size);
return NULL;
}
void operator delete[](void *obj)
{
free((mystring *)obj);
obj = NULL;
}
void operator delete(void *obj)
{
free((mystring *)obj);//不能直接free一个void *；
obj = NULL;//防止野指针
}
bool operator ==(const mystring &it)
{
if (strcmp(s, it.s) == 0)//假设this->s和it的s同样,就返回true
{
return true;
}else
return false;
}
bool operator ==(const char *str)
{
if (strcmp(s, str) == 0)//假设this->s和it的s同样,就返回true
{
return true;
}else
return false;
}
//假设返回的是char，代表的是一个右值，右值是不能直接赋值的，
//假设返回的是char的引用，那么[]就能够当左值使用了
char &operator[](int index)
{
return s[index];
}
void operator ()(const char *str)//重载函数调用操作符
{
strcpy(s, str);
}
void operator ()(int i)
{
sprintf(s, "%d", i);
}
operator int()
{
return atoi(s);
}
friend mystring operator +(const char *str, const mystring &it);
};
bool operator ==(const char *str, const mystring &it)
{
if (strcmp(str, it.s) == 0)
{
return true;
}else
return false;
}
//操作符重载，有一个最基本条件，就是一定有一个一元是一个自己定义的C++类
//假设两个都是基本数据类型操作符重载是非法的
mystring operator +(const char *str, const mystring &it)
{
mystring str1;
char buf[1024] = {0};
sprintf(buf, "%s%s", str, it.s);
strcpy(str1.s, buf);
return str1;
}
mystring operator ++(mystring &it)
{
int len = strlen(it.s);
for(int i = 0;i < len; i++)
{
it.s[i]++;//让s的第一个成员char + 1,就是将s[0]相应字符的ASCII码 + 1
}
return it;
}
mystring operator +(int i, const mystring &it)
{
mystring str1;
char buf[1024] = {0};
sprintf(buf, "%d%s", i, it.s);
strcpy(str1.s, buf);
return str1;
}
class demo
{
public:
demo()
{
}
};
void test(int i)
{
cout << i << endl;
}
int main()
{
// mystring str;
// str << "123";
// test(str);//导致C++编译器自己主动的配备int（）操作符
mystring *p = new mystring;
delete p;
// mystring *p = (mystring *)malloc(sizeof(mystring));
// free(p);
return 0;
}
int main04()
{
mystring str1;
str1 << "hello";
mystring str2;
str2 << "hello";
if ("hello" == str1)
{
cout << "true" << endl;
}else
{
cout << "fasle" << endl;
}
str1[2] = 'a';
//str1("aaaaaaaa");
str1(10);
cout << str1.s << endl;
return 0;
}
int main03()
{
cout << "mystring size =" << sizeof(mystring) << endl;
mystring str1;
str1 = "hello";
mystring str2;
str2 = " world";
mystring str3;
//str3 = str1 + str2;//对C++编译器来讲，不能识别两个类+是什么含义
//str3 = str1 + "aaaaaaaaaaaa";
//str3 = str1 + 100;
//str3 = "AAAAA" + str1;
str3 = 100 + str1;
str3 += "BBBBBB";
str3 << "CCCCC";
char buf[1024] = {0};
str3 >> buf;
str2 = str3++;
str2 = ++str3;
mystring *pstr = new mystring;
delete pstr;
cout << str3.s << endl;
return 0;
}
int main01()
{
mystring str1;
strcpy(str1.s, "hello world");
mystring str2;
str2 = str1;//这个过程不是拷贝构造的过程，仅仅是=号操作
//str2.operator =(str1);//和直接写=号是一摸一样的
cout << str2.s << endl;
str2 = "test";//C++编译器不能理解把一个字符串赋给一个类是什么含义
mystring str3;
str3 = str2 = 100;
//str3 = str2.operator =(100);//上一条语句的等效语法
cout << str2.s << endl;
return 0;
}