一个有用的ANSI字符串类String的实现及使用演示

最新推荐文章于 2024-05-15 17:35:56 发布

一剑

最新推荐文章于 2024-05-15 17:35:56 发布

阅读量1k

点赞数

分类专栏： C++语言文章标签： string constructor 测试 destructor testing delete

本文链接：https://blog.csdn.net/loomman/article/details/2973063

版权

C++语言专栏收录该内容

13 篇文章 0 订阅

订阅专栏

和C#不一样，C和C++的内部都没有字符串数据类型，但是我们可以用C++建立一个实现字符串相关操作的类型：String

并且利用重载的机制提供方便操作字符串的相关运算符集。

下面的程序分成两个部分：

（1）String类：类头String.h和类实现String.cpp

（2）String类使用演示程序Main.cpp

类头文件String.h代码如下：

 
 #ifndef STRING_H 
#define STRING_H 
#include <iostream> 
using namespace std;
class String
{
    friend ostream & operator<<(ostream & output, const String & s);
    friend istream & operator>>(istream & input, String & s);
public:
    String(const char* = "");
    String(const String &);
    ~String();
    const String & operator=(const String &);   //赋值 
    String & operator+=(const String &);        //字符串连接 
    int operator!() const;                      //String为空？ 
    int operator==(const String &) const;       //测试s1==s2 
    int operator!=(const String &) const;       //测试s1!=s2 
    int operator<(const String &) const;        //测试s1<s2 
    int operator>(const String &) const;        //测试s1>s2 
    int operator<=(const String &) const;       //测试s1<=s2 
    int operator>=(const String &) const;       //测试s1>=s2 
    char & operator[](int);                     //返回对字符的引用 
    String & operator()(int, int);              //返回一个子字符串 
    int GetLength() const;                      //返回字符串的长度，不包括结尾的/0 
private:
    char* sPtr;                                 //指向字符串起始位置的指针 
    int length;                                 //字符串的长度 
};
#endif
 

类实现文件String.cpp代码如下：

 
 #include <iostream> 
#include <string.h> 
#include <assert.h> 
#include "String.h" 
ostream & operator<<(ostream & output, const String & s)
{
    output<<s.sPtr;
    return output;
}
istream & operator>>(istream & input, String & s)
{
    static char temp[100];
    input>>temp;
    s = temp;
    return input;
}
String::String(const char * s)
{
    cout<<"Convention constructor:"<<s<<endl;
    length = strlen(s);
    sPtr = new char[length+1];
    assert(sPtr!=0);
    strcpy(sPtr, s);
}
String::String(const String & copy)
{
    cout<<"Copy constructor:"<<copy.sPtr<<endl;
    length = copy.length;
    sPtr = new char[length+1];
    assert(sPtr != 0);
    strcpy(sPtr, copy.sPtr);
}
String::~String()
{
    cout<<"Destructor:"<<sPtr<<endl;
    delete[] sPtr;
}
const String & String::operator=(const String & right)
{
    cout<<"operator = called"<<endl;
    if(&right != this)   //避免自我赋值 
    {
        delete[] sPtr;
        length = right.length;
        sPtr = new char[length+1];
        assert(sPtr!=0);
        strcpy(sPtr, right.sPtr);
    }
    else
    {
        cout<<"Attempt assignment of a String to itself/n";
    }
    return *this;
}
String & String::operator+=(const String & right)
{
    char* tempPtr = sPtr;
    length += right.length;
    sPtr = new char[length+1];
    assert(sPtr!=0);
    strcpy(sPtr, tempPtr);
    strcat(sPtr, right.sPtr);
    delete[] tempPtr;
    return *this;
}
//字符串为空？ 
int String::operator !() const
{
    return length == 0;
}
int String::operator==(const String & right) const
{
    return strcmp(sPtr, right.sPtr)==0;
}
int String::operator!=(const String & right) const
{
    return strcmp(sPtr, right.sPtr)!=0;
}
int String::operator<(const String & right) const
{
    return strcmp(sPtr, right.sPtr)<0;
}
int String::operator>(const String & right) const
{
    return strcmp(sPtr, right.sPtr)>0;
}
int String::operator<=(const String & right) const
{
    return strcmp(sPtr, right.sPtr)<=0;
}
int String::operator>=(const String & right) const
{
    return strcmp(sPtr, right.sPtr)>=0;
}
//返回对String中某个字符的引用 
char & String::operator [](int subscript)
{
    //首先测试下标是否越界 
    assert(subscript>=0 && subscript<length);
    return sPtr[subscript];
}
String & String::operator()(int index, int sublength)
{
    //首先测试下标是否越界 
    assert(index>=0 && index<length && sublength >= 0);
    String * subPtr = new String;
    assert(subPtr!=0);
    //计算子字符串长度 
    int size = 0;
    if(sublength == 0 || (index+sublength>length))
    {
        size = length - index + 1;
    }
    else
    {
        size = sublength + 1;
    }
    //分配子字符串内存 
    delete subPtr->sPtr;
    subPtr->length = size;
    subPtr->sPtr = new char[size];
    assert(subPtr->sPtr!=0);
    int i = index, j=0;
    //把子字符串拷贝到新的对象中 
    for( ; i<index+size-1; i++, j++)
    {
        subPtr->sPtr[j] = sPtr[i];
    }
    subPtr->sPtr[j] = '/0';
    return *subPtr;
}
int String::GetLength() const
{
    return length;
}
 

String类使用演示程序Main.cpp代码如下：

 
 #include <iostream> 
#include "String.h" 
int main()
{
    cout<<"---------------------------------------------------------------------------------------------------------/n"; 
    cout<<"                   一个有用的ANSI字符串类String的实现及使用演示程序                    /n"; 
    cout<<"by 一剑(Loomman),QQ:28077188,MSN: Loomman@hotmail.com QQ裙：30515563/n"; 
    cout<<"---------------------------------------------------------------------------------------------------------/n/n"; 
    String s1(" happy"), s2(" birthday"), s3;
    cout<<"s1 is /""<<s1<<"/"; s2 is /""<<s2
        <<"/"; s3 is empty /n"
        <<"The results of comparing s2 and s1:"
        <<"/ns2==s1 yields "<<(s2==s1)
        <<"/ns2!=s1 yields "<<(s2!=s1)
        <<"/ns2>s1 yields "<<(s2>s1)
        <<"/ns2<s1 yields "<<(s2<s1)
        <<"/ns2>=s1 yields "<<(s2>=s1)
        <<"/ns2<=s1 yields "<<(s2<=s1)<<"/n/n";
    cout<<"Testing! s3:/n";
    if(!s3)
    {
        cout<<"s3 is empty; assigning s1 to s3; /n";
        s3 = s1;
        cout<<"s3 is /""<<s3<<"/"/n/n";
    }
    cout<<"s1+=s2 yields s1=";
    s1+=s2;
    cout<<s1<<"/n/n";
    cout<<"s1+=/" to you/" yields/n";
    s1+=" to you";
    cout<<"s1="<<s1<<"/n/n";
    cout<<"The substring of s1 starting at /n"
        <<"location 0 for 14 characters, s1(0, 14), is:"
        <<s1(0, 14)<<"/n/n";
    cout<<"The substring of s1 starting at /n"
        <<"location 15, s1(15, 0) is:"
        <<s1(15, 0)<<"/n/n";
    String * s4Ptr = new String(s1);
    cout<<"*s4Ptr="<<*s4Ptr<<"/n/n";
    cout<<"assigning *s4Ptr to *s4Ptr/n";
    *s4Ptr = *s4Ptr;
    cout<<"*s4Ptr="<<*s4Ptr<<endl;
    delete s4Ptr;
    s1[0] = 'H';
    s1[6] = 'B';
    int a;
    cin>>a;
    return a;
}
 

程序运行效果：

----------------------------------------------------------------------------------------------------------
      一个有用的ANSI字符串类String的实现及使用演示程序
      by 一剑(Loomman),QQ:28077188,MSN: Loomman@hotmail.com QQ裙：30515563
      ----------------------------------------------------------------------------------------------------------

Convention constructor: happy
Convention constructor: birthday
Convention constructor:
s1 is " happy"; s2 is " birthday"; s3 is empty
The results of comparing s2 and s1:
s2==s1 yields 0
s2!=s1 yields 1
s2>s1 yields 0
s2<s1 yields 1
s2>=s1 yields 0
s2<=s1 yields 1

Testing! s3:
s3 is empty; assigning s1 to s3;
operator = called
s3 is " happy"

s1+=s2 yields s1= happy birthday

s1+=" to you" yields
Convention constructor: to you
Destructor: to you
s1= happy birthday to you

Convention constructor:
The substring of s1 starting at
location 0 for 14 characters, s1(0, 14), is: happy birthda

Convention constructor:
The substring of s1 starting at
location 15, s1(15, 0) is: to you

Copy constructor: happy birthday to you
*s4Ptr= happy birthday to you

assigning *s4Ptr to *s4Ptr
operator = called
Attempt assignment of a String to itself
*s4Ptr= happy birthday to you
Destructor: happy birthday to you
by Loomman, QQ:28077188, MSN: Loomman@hotmail.com QQ裙：30515563 ☆程序天堂☆ 请尊重作者原创，转载注明来自裂帛一剑博客，谢谢合作。