C++ --- Day03 重载

自己封装类似C++中的string类

Mystring.h

#ifndef MYSTRING_H
#define MYSTRING_H
#include <iostream>
#include<string.h>
using namespace std;

class myString
{
    friend ostream& operator<<(ostream &cout,const myString &s);
    private:
        char *str;          //记录c风格的字符串
        int size;            //记录字符串的实际长度
    public:
        //无参构造
        myString():size(10)
        {
            str = new char[size];         //构造出一个长度为10的字符串
            strcpy(str,"");         //赋值为空串

        }
        //有参构造
        myString(const char *s)          //string  s("hello world")
        {
            size = strlen(s);
             str = new char[size+1];
             strcpy(str, s);
        }

        //拷贝构造
        myString(const myString &s);
        //析构函数
        ~myString();
        //拷贝赋值函数
        myString& operator=(const myString &s);
        //判空函数
        bool empty()const;
        //size函数
        int strsize() const;
        //c_str函数
        const char* c_str() const;
        //at函数
        char &at(int pos) const;
        //加号运算符重载
        const myString operator+(const myString &rstr) const;
        //加等于运算符重载
        myString& operator+=(const myString &rstr);
        //关系运算符重载（>）
        bool operator>(const myString &rstr) const;
        //中括号运算符重载
        char& operator[](const int pos) const;

};
void emp(const myString &s);
#endif // MYSTRING_H

Mystring.cpp

#include"Mystring.h"
void emp(const myString &s)
{
    if(s.empty())
        cout<<"为空"<<endl;
    else
        cout<<"不为空"<<endl;
}
//<<重载
ostream& operator<<(ostream &cout,const myString &s)
{
    cout << s.str;
    return cout;
}

//拷贝构造
myString::myString(const myString &s):str(new char(s.size)),size(s.size)
{
    for(int i = 0;i<s.size;i++)
    {
        *(this->str+i) = *(s.str + i);
    }

}
//析构函数
myString::~myString()
{
    if(str != nullptr)
        delete str;
    cout<< "析构函数"<<endl;
}
//拷贝赋值函数
myString& myString::operator=(const myString &s)
{
    if(this->str!=nullptr)
        delete this->str;
    this->str = new char (s.size);
    for(int i = 0;i<s.size;i++)
    {
        *(this->str+i) = *(s.str+i);
    }
    this->size = s.size;
    return *this;

}
//判空函数
bool myString::empty()const
{
    if(strlen(this->str) == 0)
        return true;
    return  false;
}
//size函数
int myString::strsize() const
{
    return strlen(this->str);
}
//c_str函数
const char* myString::c_str() const
{
    return this->str;
}
//at函数
char& myString::at(int pos) const
{
    if(pos<0 || pos > size)
        throw myString("越界！");
    return *(this->str+pos);
}
//加号运算符重载
const myString myString::operator+(const myString &rstr) const
{
    int newsize = this->size+rstr.size;
    char s[newsize];
    strcpy(s,this->str);
    strcat(s,rstr.str);
    return myString(s);
}
//加等于运算符重载
myString& myString::operator+=(const myString &rstr)
{
    char *p = this->str;
    int psize = this->size;
    this->str = nullptr;
    this->str = new char (psize+rstr.size);
    strcpy(this->str,p);
    delete p;
    strcat(this->str,rstr.str);
    return *this;
}
//关系运算符重载（>）
bool myString::operator>(const myString &rstr) const
{
    if(strcmp(this->str,rstr.str)>0)
        return true;
    return false;
}
//中括号运算符重载
char& myString::operator[](const int pos) const
{
    if(pos>=0&&pos<size)
        return *(this->str+pos);
    throw myString("越界！");
}

main.cpp

#include"Mystring.h"
void emp(const myString &s)
{
    if(s.empty())
        cout<<"为空"<<endl;
    else
        cout<<"不为空"<<endl;
}
//<<重载
ostream& operator<<(ostream &cout,const myString &s)
{
    cout << s.str;
    return cout;
}

//拷贝构造
myString::myString(const myString &s):str(new char[s.size]),size(s.size)
{
    for(int i = 0;i<s.size;i++)
    {
        *(this->str+i) = *(s.str + i);
    }

}
//析构函数
myString::~myString()
{
    if(str != nullptr)
        delete[] str;
    cout<< "析构函数"<<endl;
}
//拷贝赋值函数
myString& myString::operator=(const myString &s)
{
    if(this->str!=nullptr)
        delete[] this->str;
    this->str = new char [s.size];
    for(int i = 0;i<s.size;i++)
    {
        *(this->str+i) = *(s.str+i);
    }
    this->size = s.size;
    return *this;

}
//判空函数
bool myString::empty()const
{
    if(strlen(this->str) == 0)
        return true;
    return  false;
}
//size函数
int myString::strsize() const
{
    return strlen(this->str);
}
//c_str函数
const char* myString::c_str() const
{
    return this->str;
}
//at函数
char& myString::at(int pos) const
{
    if(pos<0 || pos > size)
        throw myString("越界！");
    return *(this->str+pos);
}
//加号运算符重载
const myString myString::operator+(const myString &rstr) const
{
    int newsize = this->size+rstr.size;
    char s[newsize];
    strcpy(s,this->str);
    strcat(s,rstr.str);
    return myString(s);
}
//加等于运算符重载
myString& myString::operator+=(const myString &rstr)
{
    char *p = this->str;
    int psize = this->size;
    this->str = nullptr;
    this->str = new char (psize+rstr.size);
    strcpy(this->str,p);
    delete[] p;
    strcat(this->str,rstr.str);
    return *this;
}
//关系运算符重载（>）
bool myString::operator>(const myString &rstr) const
{
    if(strcmp(this->str,rstr.str)>0)
        return true;
    return false;
}
//中括号运算符重载
char& myString::operator[](const int pos) const
{
    if(pos>=0&&pos<size)
        return *(this->str+pos);
    throw myString("越界！");
}