自定义的string类

头文件Hi_String.h

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


class Hi_String
{
public:
    Hi_String();
    ~Hi_String();
    Hi_String(const Hi_String& mystring);
    Hi_String(const char* const mystring);

    int GetLen() const {return itsLen;}
    const char* GetString() const {return itsString;}


    
/*
对于等号可以这样理解
s1=s2相当于实例化对象s1调用函数等号；
而s2相当于函数等号的输入参数
所以operator=输入参数不可改变的const Hi_String& mystring;
*/
/*
关于重载符号函数的函数返回不是很明白；
声明时候用Hi_String&\Hi_String\void
*/
    Hi_String& operator=(const Hi_String& mystring);
    Hi_String operator+(const Hi_String& mystring);
    void operator+=(const Hi_String& mystring);

    char& operator[](int offset);
    char operator[](int offset) const;

    
private:
    int itsLen;
    char* itsString;

    //为什么要加一个私有构造函数；意义何在
    Hi_String(int Len);
/*
因为在operator+时，需要创建一定长度的Hi_String;
但是这个构造函数不想让用户用；只在自己的公有函数中调用
所以声明为私有构造函数
*/
    
};

 

源文件Hi_String.cpp

#include"Hi_String.h"

Hi_String::Hi_String()
{
    itsString = new char(1);
    itsString = '\0';
    itsLen = 0;
}

Hi_String::Hi_String(const Hi_String & mystring)
{
    itsLen= mystring.GetLen();
    itsString = new char(itsLen+1);
    for(int i=0;i<itsLen;++i)
    {
        itsString[i]=mystring[i];
    }
    itsString[itsLen]='\0';
}

Hi_String::Hi_String(const char * const mystring)
{
    itsLen = strlen(mystring);
    itsString = new char(itsLen+1);
    for(int i=0;i<itsLen;++i)
    {
        itsString[i]=mystring[i];
    }
    itsString[itsLen]='\0';
}

Hi_String::Hi_String(int Len)
{
    itsString = new char(Len+1);
    itsLen = Len;
    for(int i=0;i<itsLen+1;++i)
    {
        itsString[i]='\0';
    }
}

Hi_String::~Hi_String()
{
//注意析构字符数组的方式
    delete [] itsString;
    itsLen=0;
}

Hi_String& Hi_String::operator=(const Hi_String& mystring)
{
    if(this == &mystring)
    {
        return *this;
    }

    delete [] itsString;
    itsLen = mystring.GetLen();
    itsString = new char(itsLen+1);
    for(int i=0;i<itsLen;++i)
    {
        itsString[i]=mystring[i];
    }
    itsString[itsLen]='\0';
    return *this;    
}

/*
注意在函数里创建字符数组；是在堆上创建的；
当函数返回时；会销毁创建的堆；
所以函数不返回在堆上创建的Hi_String的指针；
因为函数一但返回；堆销毁，指针无效；
这里返回的是Hi_String;是堆上创建数组的一份拷贝
*/
Hi_String Hi_String::operator+(const Hi_String& mystring)
{
    int totaolLen = itsLen + mystring.GetLen();
    Hi_String temp(totaolLen);
    for(int i=0;i<itsLen;++i)
    {
        temp[i] = itsString[i];
    }
    for(int j=mystring.GetLen();j<totaolLen;j++)
    {
        temp[j] = mystring[j];
    }
//并没有给temp[totalLen]='\0'
//是因为在temp(totaolLen)私有构造函数
//中已经给temp[totalLen]赋'\0'了
    return temp;    
}


void Hi_String::operator+=(const Hi_String& mystring)
{
    int totolLen = itsLen + mystring.GetLen();
    Hi_String temp(totolLen);
    for(int i=0;i<itsLen;++i)
    {
        temp[i] = itsString[i];
    }
    for(int j=mystring.GetLen();j<totolLen;j++)
    {
        temp[j] = mystring[j];
    }
//注意函数返回；所以这里直接等于就可以了
    *this = temp[totolLen];
}

char Hi_String::operator[](int offset) const
{
    if(offset>itsLen)
        return itsString[itsLen-1];
    else
        return itsString[offset];
}

char& Hi_String::operator[](int offset)
{
    if(offset>itsLen)
        return itsString[itsLen-1];
    else
        return itsString[offset];
}


int main()
{
    Hi_String ztao("ztao");
    cout<<ztao.GetString()<<endl;
    return 0;
}

 

转载于:https://www.cnblogs.com/ztteng/p/3251401.html