通过自己创造string来探究其内部构造

最新推荐文章于 2023-10-24 20:10:16 发布

wonghifong0223

最新推荐文章于 2023-10-24 20:10:16 发布

阅读量462

点赞数

分类专栏： C++ 数据结构文章标签： C++ 数据结构

本文链接：https://blog.csdn.net/wonghifong0223/article/details/48577699

版权

C++ 同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

数据结构

3 篇文章 0 订阅

订阅专栏

说string是编程时用的最多的库类一点也不为过，其实，我们也能通过编程来自己实现这个类，现在就让我们来一探string库内部的奥秘吧。

实现string可以用两种办法，因为string就是一个char的有序表，所以可以通过线性表和链表来实现，从直观上讲，线性表跟符合string的本质，不过我们选择用char指针动态分配char数组来实现。在私有对象里 , 除了用来分配的char数组外，还要有一个int用来保存string长度。对于构造函数，首先是一个无参数的默认构造函数，然后还要有一个接受C风格字符串的构造函数，还要在定义一个析构函数。所以先写出下列代码：

class String{
    private:
        int length;
        char * str;
    public:
        String() = default;
        String(const char *);
        ~String(){ delete [] str}
};

接下来我们考虑如何定义这两个函数：（已引入cstring头文件）

String::String(){
    str = new char[1];
    length = 0;
    str[0] = '\0';
}
String::String(const char* c){
    length = strlen(c);
    str = new char[length + 1];
    strcpy(str , c);
}

接下来我们得考虑几个问题，当我们用一个String构造另一个String时（比如 String s1 = s2;），如果没有定义拷贝构造函数，编译器会帮忙定义一个默认拷贝构造函数，然而这却是帮倒忙了，因为默认的拷贝构造函数是将函数中的成员变量全部复制，换句话说，就是对每一个变量执行=赋值操作，而对于指针复制之后，就变成两个str指向同一块地址，这样必然会导致一个问题，当我们其中一个对象被销毁后，就已经把那块内存delete了，那么另一个对象的str指针就指向一块没分配的内存，更糟的是，当另一个对象被销毁时，就要delete一块已经释放的内存，这样必然导致程序出错甚至崩溃，同样的，若我们没重载=运算符，也会发生上述问题，所以我们要在class中加入上述函数：

class String{
    public:
        String(const String&);
        String& operator=(const String&);
        String& operator=(const char*);
};    //在上述的class中增加的

String::String(const String& s){
    length = s.length;
    str = new char[length + 1];
    strcpy(str , s.str);
}

String& String::operator=(const String& s){
    if(this == &s) return *this;
    delete [] str;
    length = s.length;
    str = new char[length + 1];
    strcpy(str , s.str);
    return *this;
}

String& String::operator=(const char* c){
    *this = String(c);
    return *this;
}

这里有几个问题要说明一下，首先是为什么参数都是引用常量，第一，引用比传值效率更高，第二，常量可以接纳常量和非常量，如果不是常量的话，是无法传常量进去的（其实就是非常量可以用常量引用，常量却不能用非常量引用）。为什么赋值函数返回的是自身的引用，其一也是从效率出发，其二是因为这是赋值函数的惯例，这样就能够进行连续赋值（比如 s1 = s2 = s3），最后，我们为什么应该对赋值函数定义一个接受C风格字符串的版本呢，因为之前我们定义了String(const String &) 这个构造函数，当我们要把一个C风格字符串赋值给一个已经定义好的String（即已经执行过构造函数了）时，就在这里进行一次类型转换，把参数转化成String类型，在调用以String为参数的版本的赋值函数。

接下来一个没有BUG的String类终于出来了，但是它还没什么功能，于是我们为他增加多一点功能，首先重载+运算符：

class String{
    public:
        String operator+(const String&);
        String operator+(const char*);
};

String operator+(const char* c , const String& s);

String String::operator+(const String& s){
    char temp[length + s.length + 1];
    strcpy(temp , str);
    strcpy(&temp[length] , s.str);
    return String(temp);
}

String String::operator+(const char* c){
    return *this + String(c);
}

String operator+(const char* c , const String& s){
    return String(c) + s;
}

接下来还有一个问题，为什么这里返回的是一个局部的String ，原因是相加并不改变其中的任意一个String ，而且不能返回局部值得引用（那样的话离开函数作用域那个引用就无效了）所以我们只能返回一个新的String ，这也符合C++其他的类型的定义。再者，为什么第二个函数在类内没有进行声明，反而跑到外面去声明，这是因为 + 号的左边（即+的调用者，const char* c）并不是一个String ，而且该操作也不会访问String的私有成员，所以不需要声明友元函数。顺便说一句，关于参数为char*的版本是为了说明其内部的转换过程，即使不定义也会自动转换，但这其实是一种名为代理的模式，即使用其他同名重载函数来代替该函数工作。

既然有了+的定义，为什么没有+=的定义呢，这个作为练习留给读者完成（思考返回的是引用还是值）。

最后我们再来定义输入输出，说白了就是要重载<< 和>> ，对于输出<<非常简单，只需要将字符串输出即可，输入会稍微复杂一点，涉及重载>>和getline版本：

class String{
    public:
        friend ostream& operator<<(ostream& , const String&);
        friend istream& operator>>(istream& , String&);
};

istream& getline(istream& , String&);

ostream& operator<<(ostream& os , const String& s){
    os << s.str;
    return os;
}

istream& operator>>(istream& is , String& s){
    char c[255];
    int i = 0;
    while(i < 254 && (c[i] = is.get()) != '\0' && c[i] != '\n'){
    i++;
    }
    c[i] = '\0';
    if(is)
        s = String(c);
    return is;
}

istream& getline(istream& is , String& s){
    char c[255];
    is.getline(c , 255);
    if(is){
        s = String(c);
    }
    while(is && is.get() != '\n')
        continue;
    return is;
}

与标准库一样，重载的版本返回了流本身，在这里提一下， 255为输入的最大字符数，超过的话， >>版本会将后面的字符留在流中（当然前提是没遇到空格或回车），

getline的话会将超出部分丢弃。如果流被破坏，则原本的字符不会受到影响。

还有两个比较重要的函数，一个就是返回字符串长度的size() ，另一个就是重载的[ ] 运算符：

class String{
    public:
        int size(){ return length;}
        char& operator[](int index){
            return str[index];
        }
        const char& operator[](int index) const {
            return str[index];
        }
}；

这里提一下为什么要重载两个版本的[ ] 运算符，第一个版本是能够任意修改的，因为任意的数组和指针访问的结果都是引用。第二个版本是适用于不改变内容或常量String访问的。

我们已经做好了一个String的框架，还有很多的成员函数没有实现，迭代器也没有完成，这部分的任务留给读者自己完成，我想说的是，不必将函数内部实现的与原版一模一样，只需要知道它的实现思路即可。