c++学习---String字符串类(类3)

根据C++ Primer上的学习，昨天晚上刚刚写的String类 ，自己完善了下。

函数全部又内联函数实现，内联函数的类体外实现都写在头文件中（.h文件），自己只定义了头文件。

String.h文件

#ifndef STRING_H
#define  STRING_H

#include  < iostream >
#include  < cstring >
#include  < cassert >
#include  < iomanip > // 使用setw()等函数
class  String;
using   namespace  std;
// 重载输入和输出操作符声明
istream &   operator >> (istream &   is ,String &  str);
ostream &   operator << (ostream &  os, const  String &  str);

class  String
... {
public:
    String();//默认构造函数
    String(const char* ch);
    String(const String& str);
    ~String();
    //赋值
    String& operator=(const String& str);
    String& operator=(const char* ch);
    //索引访问单个字符
    char& operator[](int index);
    //字符串大小
    int size();
    //访问字符串
    char* c_str();
    //两个字符串相等比较
    bool operator==(const String& str);
    bool operator==(const char* ch);
    //返回字符中出现某个字符的个数
    int count(char ch) const;
    //链接字符串
    String operator+(const String& str);
    String operator+(const char* ch);
    String& operator+=(const String& str);
    String& operator+=(const char* ch);

private:
    int _size;//字符串大小
    char* _string;//字符串
private:
    void Intial(const char* ch);
    void Intial(const String& str);
} ;
/**/ /*内联函数的类外实现在头文件中*/

// 初始化函数
void  String::Intial( const   char *  ch)
... {
    if(!ch)//初始化字符串为空
    ...{
        _size = 0;
        _string = 0;
    }
    else//不为空申请空间
    ...{
        _size = strlen(ch);
        _string = new char[_size+1];
        strcpy(_string,ch);
    }
}
void  String::Intial( const  String &  str)
... {
    _size = str._size;
    if(!str._string)//初始化字符串为空
    ...{
        _size = 0;
        _string = 0;
    }
    else//不为空申请空间
    ...{
        _string = new char[_size + 1];
        strcpy(_string,str._string);
    }
}
// 字符串大小
inline  int  String::size()
... {
    return _size;
}
// 访问字符串
char *  String::c_str()
... {
    return _string;
}
// 默认构造函数
inline String::String()
... {
    _size = 0;
    _string = 0;
}
inline String::String( const   char *  ch)
... {
    Intial(ch);
}
inline String::String( const  String &  str)
... {
    Intial(str);
}
// 析构函数
inline String:: ~ String()
... {
    delete[] _string;
}

// 索引访问单个字符
inline  char &  String:: operator  []( int  index)
... {
    assert(index>=0&&index<_size);//设置断言，防止数据越界
    return _string[index];
}
// 两个字符串相等比较
inline  bool  String:: operator   == ( const   char *  ch)
... {
    return (strcmp(_string,ch)?false:true);
}
inline  bool  String:: operator   == ( const  String &  str)
... {
    return (strcmp(_string,str._string)?false:true);
}
// 赋值
inline String &  String:: operator   = ( const   char *  ch)
... {
    //delete[] _string;
    if(_string)//源字符串不为空
    ...{
        String::~String();
    }
    Intial(ch);
    return *this;
}
inline String &  String:: operator   = ( const  String &  str)
... {
    if(this!=&str)//被赋予的不是源字符串
    ...{
        if(_string)//源字符串不为空
        ...{
            String::~String();
        }
        //delete[] _string;
        Intial(str);
    }
    return *this;
}
// 重载输入和输出操作符
inline istream &   operator   >> (istream &   is ,String &  str)
... {
    //限制输入字符4096
    const int limit_size = 4096;
    char inBuf[limit_size];
    //限制输入字符setw();
    is>>setw(limit_size)>>inBuf;
    str = inBuf;
    return is;
}
inline ostream &   operator   << (ostream &  os,String &  str)
... {
    return os<<str.c_str();
}
// 返回字符中出现某个字符的个数
inline  int  String::count( char  ch)  const
... {
    int cnt = 0;
    for(int i = 0;i < _size;++i)
    ...{
        if(_string[i]==ch)
        ...{
            ++cnt;
        }
    }
    return cnt;
}
// 链接字符串
inline String String:: operator + ( const  String &  str)
... {
    String strCat;
    if(!str._string)//被连接字符串为空则直接返回第一个字符串
    ...{
        strCat = *this;
    }
    else if(!_string)//连接的字符串为空则直接返回被链接字符串
    ...{
        strCat = str;
    }
    else//申请空间准备连接字符串
    ...{
        strCat._size = _size + str._size;
        strCat._string = new char[strCat._size+1];
        strcpy(strCat._string,_string);
        strcat(strCat._string,str._string);
    }
    return strCat;
}
inline String String:: operator + ( const   char *  ch)
... {
    String strCat;
    if(!ch)//被连接字符串为空则直接返回第一个字符串
    ...{
        strCat = *this;
    }
    else if(!_string)//连接的字符串为空则直接返回被链接字符串
    ...{
        strCat = ch;
    }
    else//申请空间准备连接字符串
    ...{
        strCat._size = _size + strlen(ch);
        strCat._string = new char[strCat._size+1];
        strcpy(strCat._string,_string);
        strcat(strCat._string,ch);
    }
    return strCat;
}
inline String &  String:: operator += ( const  String &  str)
... {
    String strL;
    if(str._string)//附加字符串不为空
    ...{
        if(!_string)//源字符串为空则直接为附加的字符串申请空间
        ...{
            _size = str._size;
            _string = new char[_size+1];
            strcpy(_string,str._string);
        }
        else//重新申请空间连接字符串
        ...{
            strL = *this;
            String::~String();
            _size = _size + str._size;
            _string = new char[_size+1];
            strcpy(_string,strL._string);
            strcat(_string,str._string);
        }
    }
    return *this;
}
inline String &  String:: operator += ( const   char *  ch)
... {
    String strL;
    if(ch)//附加字符串不为空
    ...{
        if(!_string)//源字符串为空则直接为附加的字符串申请空间
        ...{
            _size = strlen(ch);
            _string = new char[_size+1];
            strcpy(_string,ch);
        }
        else//重新申请空间连接字符串
        ...{
            strL = *this;
            String::~String();
            _size = _size + strlen(ch);
            _string = new char[_size+1];
            strcpy(_string,strL._string);
            strcat(_string,ch);
        }
    }
    return *this;
}
#endif

另外加了个小程序测试了一下。

StringCeshi.cpp文件

#include  " String.h "
#include  < iostream >
using   namespace  std;

int  main()
... {
    String a;//默认构造函数
    String b("You are a good man!");//char*构造函数
    String c(b);//拷贝构造函数
    a = "good!";//char*赋值
    //重载的<<和>>
    cout<<"a:"<<a<<" ";
    cout<<"b:"<<b<<" ";
    cout<<"c:"<<c<<" ";
    b=a;//String赋值
    a=c;//String赋值
    cout<<"a:"<<a<<" ";
    cout<<"b:"<<b<<" ";
    cout<<"c:"<<c<<" ";
    //下标
    cout<<"a[0]:"<<a[0]<<" ";
    cout<<"b[1]:"<<b[1]<<" ";
    cout<<"c[2]:"<<c[2]<<" ";
    //字符串比较
    if(a==b)
    ...{
        cout<<"a==b"<<" ";
    }
    else
    ...{
        cout<<"a!=b"<<" ";
    }
    if(a==c)
    ...{
        cout<<"a==c"<<" ";
    }
    else
    ...{
        cout<<"a!=c"<<" ";
    }
    //链接字符串
    String strM = a+b;//String参数连接
    String strN = a+"Connect char*";//String参数连接
    cout<<"a+b="<<strM<<" ";
    cout<<"a+"Connect char*"="<<strN<<" ";
    //+=char*String
    strM+=strN;
    cout<<"strM+=strN---strM="<<strM<<" ";
    //+=char*
    strN+="OK!";
    cout<<"strN+="OK!"---strN="<<strN<<" ";
    return 0;
}