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

类 ： 类的申明要加 “;”，加分号
构造函数 ： 类被实例化默认调用的函数，可以自己申明，也可以默认，无返回值，void也不行
析构函数 ： 类的实例化消失时自动调用的函数，可以自己申明
函数重载 ： 根据函数的参数数量，参数类型，但返回值类型不能区分
const应用 ：当参数为常量是，函数参数必须申明为const

---

---