c++ string的实现。

#include <iostream>
#include "malloc.h"
#include "typeinfo"

using namespace std;

unsigned int GetCharSize(const char* _p);
char * Get_p_Copyvalue(const char* _p);
void p2p_Copyvalue(const char * const sp,char* const dp);

class MyString
{
public:
    MyString();
    MyString(const char * _p);
    MyString(const MyString& _mys);
    //effect建议＝copy返回引用。自己理解主要是省去临时对象的创建和西构。因为这个和普通函数不一样。已经有隐藏参数this。
    //根本没有必要一定要返回对象。１）this已经更新了数据。不需要返回对象去副职。２）返回指针可以给连式＝，的下一个表达式传入指针（哦，不是，这里就算返回对象下一次还是传入指针）
    MyString& operator=(const MyString& _mys);
    //这里有修改char需要。所以必须返回引用或指针。而对象一定存在的情况，必须抛弃指针，而使用引用。
    char& operator[](const unsigned int index);
    //这里就感觉不能返回引用。＝copy，传入了this，返回的对象是this。而＋号虽然也传入this。但是返回的临时对象。＋号不可能去修改this。
    //那么必须返回对象，给临时对象，以便正确副职给临时变量。
    MyString operator+(const MyString& _mys);

    ~MyString();

    unsigned int getCap();

friend ostream& operator<<(ostream& os,const MyString& ms);
private:
    unsigned int str_capition;
    char * char_p;

};
unsigned int MyString::getCap()
{
    return str_capition;
}
MyString::MyString()
{
    this->char_p=(char *)malloc(32);
    this->char_p[0]=‘\0‘;
    this->str_capition=32;
}

MyString::MyString(const char* _p)
{
    if(_p==0x0)
    {
        this->char_p=(char *)malloc(32);
        this->char_p[0]=‘\0‘;
        this->str_capition=32;
    }
    else
    {
        unsigned int charSize=GetCharSize(_p);
        str_capition=charSize+1;
        char_p=Get_p_Copyvalue(_p);
    }
}

MyString::MyString(const MyString& _mys)
{
    //为什么private，而_mys.str_capition是合法的？
    str_capition=_mys.str_capition;
    char_p=Get_p_Copyvalue(_mys.char_p);
}

MyString& MyString::operator=(const MyString& _mys)
{
    unsigned int charSize=GetCharSize(_mys.char_p);
    if(this->str_capition>=charSize+1)
    {
        p2p_Copyvalue(_mys.char_p,this->char_p);
    }
    else
    {
        char * oldp=this->char_p;

        this->str_capition=_mys.str_capition;
        this->char_p=Get_p_Copyvalue(_mys.char_p);

        delete oldp;
    }
    return *this;
}

char& MyString::operator[](const unsigned int index)
{
    unsigned int charSize=GetCharSize(this->char_p);
    if(index<=charSize-1&&index>=0)
    {
        return this->char_p[index];
    }
    else
    {
        //刚开始不知如何处理，刚催返回mystring结束标志‘\0‘的地址。挺好。
        return this->char_p[charSize];
    }
}

MyString MyString::operator+(const MyString& _mys)
{
    unsigned int  lhsLen=GetCharSize(this->char_p);
    unsigned int  rhsLen=GetCharSize(_mys.char_p);
    unsigned int strCap=lhsLen+rhsLen+1;

    char * p=(char *)malloc(strCap);

    for(unsigned int i=0;i!=lhsLen;++i)
    {
        p[i]=this->char_p[i];
    }
    for(unsigned int i=0;i!=rhsLen;++i)
    {
        p[i+lhsLen]=_mys.char_p[i];
    }

    p[strCap-1]=‘\0‘;

    MyString tmp=MyString(p);
    return tmp;
}


MyString::~MyString()
{
    delete char_p;
}

int main()
{
    MyString str1="hi!";
    MyString str2=str1;
    //虽然没有直接指针的copy函数。但是其实会执行MyString::MyString(const char* _p)和MyString& MyString::operator=(const MyString& _mys)
    //隐士执行了２个函数。
    str1="hi!pp.";
    cout<<str1<<endl;
    cout<<str2<<endl;


    MyString str3="abcdefg";
    cout<<str3<<endl;
    str3=str1;
    cout<<str3<<endl;

    MyString emptystr;
    cout<<"empty:"<<emptystr<<".cap:"<<emptystr.getCap()<<endl;
    emptystr=str3;
    cout<<"empty:"<<emptystr<<".cap:"<<emptystr.getCap()<<endl;


    str3[3]=‘x‘;
    cout<<str3<<"‘"<<str3[99]<<"‘"<<endl;

    str3=str1+str2;
    cout<<str3<<endl;


    MyString str4=str1+str2;
    cout<<str4<<endl;


    char * emptyp="aaa!";
    MyString str5=MyString(emptyp);
    cout<<str5<<endl;
    emptyp=0x0;

    MyString str6=MyString(emptyp);
    cout<<"0x0 pointer:"<<str6<<"cap:"<<str6.getCap()<<endl;

    return 0;
}

unsigned int GetCharSize(const char* _p)
{
    unsigned int i=0;
    while(_p[i]!=‘\0‘)
    {
        ++i;
    }
    return i;
}

char * Get_p_Copyvalue(const char* _p)
{
    unsigned int charSize=GetCharSize(_p);
    char *  char_p=(char *)malloc(charSize+1);
    for(unsigned int i=0;i!=charSize;++i)
    {
        char_p[i]=_p[i];
    }
    char_p[charSize]=‘\0‘;
    return char_p;
}

void p2p_Copyvalue(const char * const sp,char* const dp)
{
    unsigned int charSize=GetCharSize(sp);
    for(unsigned int i=0;i!=charSize;++i)
    {
        dp[i]=sp[i];
    }
    dp[charSize]=‘\0‘;
}

ostream& operator<<(ostream& os,const MyString& ms)
{
    return os<<ms.char_p;
}