C++编程笔记 一（函数重载与运算符重载）

#include <string.h>
#include <stdlib.h>
#include <iostream>
using namespace std;//命名空间 std
class mystring
{
private://私有数据类型
char *data;//字符型
unsigned int space;//分配多少char的空间
public:
mystring(void);//默认构造函数
mystring(const char *p);//带参数的构造函数
mystring(mystring &s); //类似拷贝构造函数
~mystring(void);//析构函数
char *c_str(void);//返回字符串首地址
bool clear(void);
//重载运算符"+"号，返回值为mystring类型，参数const
const mystring  operator +(const char *s);
//重载运算符"="，返回一个mystring类的引用，参数const字符串
mystring & operator =(const char *s);
//"="函数重载，返回值mystring的引用，参数mystring类引用
mystring & operator =(const mystring &s);
};//class类定义加分号，和struct结构体相同
mystring::mystring(mystring &s)//构造函数
//参数为mystring的应用，即把mystring s的内容复制到this指向的data
{
data = (char *)malloc(s.space);//申请s对应的空间
strcpy(data,s.data);//复制
space = s.space;//space赋值
}
mystring::mystring(void)//无参数
{
//申请一个char字节
data = (char *)malloc(sizeof(char));
data = '\0';
space = 1;//space为1
}
mystring::mystring(const char *p)
{
//参数为char *p，即把p的字符串复制到this指向的data
int n = strlen(p);
data = (char *)malloc(sizeof(char) * (n+1));
memcpy(data,p,n);//或者strcpy（data，p）；space = n + 1
*(data+n) = '\0';
space = n+1;
}
mystring::~mystring(void)
{
//析构函数调用一次，释放申请的空间
free(data);
}
char *mystring::c_str(void)
{
//返回字符串首地址
return data;
}
const mystring mystring::operator+(const char *s)
{
//重载"+"，返回mystring类，可以用一个mystirng类接住
mystring tmp(*this);//定义个局部变量tmp，参数为*this代表tmp以this构造自己
if(strlen(s) + strlen(tmp.data) <= tmp.space-1 )
{
//如果space空间足够s和data，且最后的'\0'，追加即可
strcat(tmp.data,s);
return  tmp;//返回值tmp，不能返回局部变量指针
}
else
{
//否则重新申请空间，复制，追加，可以用strcpy（）代替memcpy（），
//然后直接strcat（）
int n = strlen(s);
char *newdata = (char *)malloc(sizeof(char) * (n + strlen(tmp.data) + 1));
memcpy(newdata,tmp.data,space-1);
memcpy(newdata+tmp.space-1,s,n);
*(newdata+n+tmp.space) = '\0';
tmp.space = n + tmp.space;
free(tmp.data);
tmp.data = newdata;
}
return  tmp;
}
mystring & mystring::operator =(const char *s)
{
//重载运算符"="，如果参数为char *，然后判断空间，追加或者申请空间追加
if(strlen(s) < space)
{
strcpy(data,s);
return *this;
}

int n = strlen(s);
char *newdata = (char *)malloc(sizeof(char )  * (n+1));
memcpy(newdata,s,n);
*(newdata+n) = '\0';
free(data);
data = newdata;
return *this;

}
mystring& mystring::operator =(const mystring &s)
{
//重载"="，如果参数为mystring，首先判断参数是否为自己，如果是的话，直接返回自己，如果不是，free自己的data，复制，再返回自己
if(this ==  &s)
{
return *this;
}
free(data);
data = (char *)malloc(s.space * sizeof(char));
strcpy(data,s.data);
space = s.space;
return *this;
}
int main()
{
char *ch = NULL ;
mystring s("hello");//因为"hello"为常量字符串，所以上面的函数为const，C++对参数及其指针要求严格
mystring s1 ;

s1 = (s+"world");
mystring s2 = s1;
cout << s2.c_str()<<endl;
}