字符串类示例

.head

#pragma once
#include<iostream>
#include<string>
#include<stdlib.h>
#include<ctype.h>
using namespace std;

class TString
{
public:
    //输入/输出操作符
    //构造函数，创建一个空字符对象
    TString();
    //创建一个字符串对象，该对象包含指向字符的s指针
    //s必须以NULL结尾，从s中复制字符
    TString(const char* s);
    //创建一个包含单个字符aChar的字符串
    TString(char aChar);
    TString(const TString& arg);//拷贝构造函数
    ~TString();//析构函数
    //赋值操作符
    TString& operator=(const TString& arg);
    TString& operator=(const char* s);
    TString& operator=(char aChar);
    //返回对象当前储存的字符个数
    int Size() const;
    //返回posn中len长度的子字符串
    TString operator()(unsigned posn, unsigned len) const;
    //返回下表为n的字符
    char operator()(unsigned n) const;
    //返回对下标为n的字符的引用
    const char& operator[](unsigned n) const;
    //返回指向内部数据的指针，当心
    const char* c_str()const { return _str; };
    //以下方法将修改原始对象。
    //把其他对象中的字符附加在*this后
    TString& operator+=(const TString& other);
    //在字符串中改动字符的情况
    TString& ToLower();//将大写字符转换成小写
    TString& ToUpper();//将小写字符转换成大写
private:
    //length是存储在对象中的字符个数，但是str所指向的内存至少要length+1长度
    unsigned _length;
    char* _str;//指向字符的指针

};

//支持TString类的非成员函数
//返回一个新TSring类的对象，该对象为one和two的级联
TString operator+(const TString& one, const TString& two);
//输入/输出操作符
ostream& operator<<(ostream& o, const TString& s);
istream& operator >> (istream& stream, TString& s);
//关系操作符，基于ASCII字符集比较。
//如果两字符串对象包含相同的字符，则两对象相等。
bool operator==(const TString& first, const TString& second);
bool operator!=(const TString& first, const TString& second);
bool operator<(const TString& first, const TString& second);
bool operator>(const TString& first, const TString& second);
bool operator>=(const TString& first, const TString& second);
bool operator<=(const TString& first, const TString& second);

.cpp

#include "TString.h"



TString::TString()
{
    _str = 0;
    _length = 0;
}


TString::TString(const char* s)
{
    if (s&&*s)
    {
        //指针不为0且指向有效字符
        _length = strlen(s);
        _str = new char[_length + 1];
        strcpy(_str, s);
    }
    else
    {
        _str = 0;
        _length = 0;
    }
}

TString::TString(char achar)
{
    if (achar)
    {
        _length = 1;
        _str = new char[2];
        _str[0] = achar;
        _str[1] = '\0';
    }
    else
    {
        _str = 0;
        _length = 0;
    }
}

TString::TString(const TString& arg)
{
    if (arg._str != 0) {
        this->_str = new char[arg._length + 1];
        strcpy(this->_str, arg._str);
        _length = this->_length;
    }
    else
    {
        _str = 0;
        _length = 0;
    }
}


TString::~TString()
{
    if (_str != 0) delete[] _str;
}


TString& TString::operator=(const TString& arg)
{
    if (this == &arg)
        return *this;
    if (this->_length >= arg._length)
    {
        if (arg._str != 0)
            strcpy(this->_str, arg._str);
        else
            this->_str = 0;
        this->_length = arg._length;
        return *this;
    }
    else
    {
        //*this没有足够空间,_arg更大；
        delete[] this->_str;
        this->_length = arg._length;
        if (this->_length)
        {
            this->_str = new char[this->_length + 1];
            strcpy(this->_str, arg._str);
        }
        else
            this->_length = 0;
    }
    return *this;
}



TString& TString::operator=(const char* s)
{
    if (s == 0 || *s == 0)
    {
        delete[] _str;
        _length = 0;
        _str = 0;
        return *this;
    }
    int slength = strlen(s);
    if (_length >= slength)
        strcpy(_str, s);
    else
    {
        delete[] _str;
        _str = new char[slength + 1];
        strcpy(_str, s);
    }
    _length = slength;
    return *this;
}


TString& TString::operator=(char aChar)
{
    char a[2];
    a[0] = aChar;
    a[1] = '\0';
    return (*this = a);//调用上面的操作符
}


int TString::Size() const { return _length; }

TString TString::operator()(unsigned posn, unsigned len) const
{
    if (posn > this->_length)
        return " ";
    else
        if (posn + len > this->_length)
            len = this->_length - posn;
    TString result;
    if (len)
    {
        result._str = new char[len + 1];
        strncpy(result._str, this->_str + posn, len);
        result._length = len;
        result._str[len] = '\0';
    }
    return result;
}


char TString::operator()(unsigned n) const
{
    if (n > this->_length)
        return 0;
    else return this->_str[n];
}



const char& TString::operator[](unsigned n) const
{
    if (n < this->_length)
        return this->_str[n];
    cout << "Invalid subscript:" << n << endl;
    exit(-1);
    return this->_str[0];
}


TString& TString::operator+=(const TString& other)
{
    if (other.Size())
    {
        this->_length += other.Size();
        char *newstr = new char[this->_length + 1];
        if (this->Size())
            strcpy(newstr, this->_str);
        else
            *newstr = '\0';
        strcat(newstr, other._str);
        delete[]this->_str;
        this->_str = newstr;
    }
    return *this;
}


TString& TString::ToLower()
{
    if (this->_str&&*this->_str)
    {
        char *p = this->_str;
        while (*p)
        {
            *p = tolower(*p);
            p++;
        }
    }
    return *this;
}


TString& TString::ToUpper()
{
    if (this->_str&&*this->_str)
    {
        char *p = this->_str;
        while (*p)
        {
            *p = toupper(*p);
            p++;
        }
    }
    return *this;
}


ostream& operator<< (ostream& o, const TString& s)
{
    if (s.c_str())
        o << s.c_str();
    return o;
}


istream& operator >> (istream& stream, TString& s)
{
    char c;
    s = " ";
    while (stream.get(c) && isspace(c))
        ;//什么也不做
    if (stream)
    {
        //stream正常的话
        //读取字符直到遇到空白
        do
        {
            s += c;
        } while (stream.get(c) && !isspace(c));
        if (stream)  //未读取额外字符
            stream.putback(c);
    }
    return stream;
}