C++标准库中string的三种底层实现方式

最新推荐文章于 2024-07-03 16:56:28 发布
最新推荐文章于 2024-07-03 16:56:28 发布
阅读量3.1k 收藏 24
点赞数 9
分类专栏： C++ 文章标签： c++ 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yolan2626/article/details/105705571
版权



引言

我们都知道， std::string的一些基本功能和用法，但它底层到底是如何实现的呢? 其实在std::string的历史中，出现过几种不同的方式。

可以从一个简单的问题来探索，一个std::string对象占据的内存空间有多大，即 sizeof(std::string)的值为多大？如果我们在不同的编译器（VC++, GNU, Clang++）上去测试，可能会发现其值并不相同；即使是GNU，不同的版本，获取的值也是不同的。

虽然历史上的实现有多种，但基本上有三种方式：

  • Eager Copy(深拷贝)
  • COW（Copy-On-Write 写时复制）：14.04版本ubuntu
  • SSO(Short String Optimization - 短字符串优化)：小于15字节，栈存放字符串；大于15字节，栈存放指针，指针指向堆

每种实现，std::string都包含了下面的信息：

  • 字符串的大小
  • 能够容纳的字符数量
  • 字符串内容本身



Eager Copy 深拷贝

最简单的就是 深拷贝 了。无论什么情况，都是采用拷贝字符串内容的方式解决，这也是之前已经实现过的方式。这种实现方式，在需要 对字符串进行频繁复制而又并不改变字符串内容 时，效率比较低下。所以需要对其实现进行优化，之后便出现了下面的COW的实现方式。



COW(Copy-On-Write) 写时复制

当两个std::string发生复制构造或者赋值时，不会复制字符串内容，而是 增加一个引用计数，然后字符串指针进行浅拷贝，其执行效率为O(1)。只有当 需要修改 其中一个字符串内容时，才 执行真正的复制。

引用计数只可以存放到堆空间，要对引用计数进行修改

  • 当引用计数（_count）为普通数据成员。因为构造函数中，传入的对象用 const 进行修饰 （const 不能去掉，参见拷贝构造函数，传递一个临时对象，左值引用绑定到右值，错误），其成员_count 是不能修改的；
  • 当引用计数（_count）为 static 全局静态数据成员。 这样创建多个对象时，使用的引用计数都为同一个
  • 引用计数在堆空间放在存放数据位置的前面，放在后面对数据产生影响

其实现的示意图，有下面两种形式：

第一种形式

在这里插入图片描述

std::string的数据成员就是:
class string 
{
private:
	Allocator _allocator;
	size_t size;
	size_t capacity;
	char * pointer;
};

第二种形式
在这里插入图片描述
std::string的数据成员就只有一个了:

class string {
private:
	char * _pointer;
};

为了实现的简单，在GNU4.8.4的中，采用的是实现2的形式。从上面的实现，我们看到引用计数并没有与std::string的数据成员放在一起，为什么呢？

当执行复制构造或赋值 时，引用计数加1，std::string对象共享字符串内容；

当 std::string对象销毁时，并不直接释放字符串所在的空间，而是先将引用计数减1， 直到引用计数为0时，则真正释放字符串内容所在的空间。

再思考一下，既然涉及到了引用计数，那么在多线程环境下，涉及到修改引用计数的操作，是否是线程安全的呢？为了解决这个问题，GNU4.8.4的实现中，采用了原子操作（不会被线程调度机制打断的操作）。



SSO（Short String Optimization）短字符串优化

目前，在VC++、GNU5.x.x以上、Clang++上，std::string实现均采用了SSO的实现。

通常来说，一个程序里用到的字符串大部分都很短小，而在64位机器上，一个char* 指针就占用了8个字节，所以SSO就出现了，其核心思想是：发生拷贝时要复制一个指针，对小字符串来说，为啥不直接复制整个字符串呢，说不定还没有复制一个指针的代价大。其实现示意图如下：
在这里插入图片描述
std::string的数据成员：

class string 
{
	union Buffer
	{
		char * _pointer;
		char _local[16];
	}; 
	
	Buffer _buffer;
	size_t _size;
	size_t _capacity;
};

当字符串的长度小于等于15个字节时，buffer直接存放整个字符串；当字符串大于 15个字节时，buffer存放的就是一个指针，指向堆空间的区域。 这样做的好处是， 当字符串较小时，直接拷贝字符串，放在string内部，不用获取堆空间，开销小。



最佳策略

以上三种方式，都不能解决所有可能遇到的字符串的情况，各有所长，又各有缺陷。综合考虑所有情况之后，facebook 开源的 folly 库中，实现了一个 fbstring, 它根据字符串的不同长度使用不同的拷贝策略， 最终每个fbstring对象占据的空间大小都是24字节。

  1. 很短的（0~22）字符串用SSO，23字节表示字符串（包括’\0’），1字节表示长度
  2. 中等长度的（23~255）字符串用 eager copy，8字节字符串指针，8字节size， 8字节capacity.
  3. 很长的(大于255)字符串用COW，8字节指针（字符串和引用计数），8字节 size，8字节capacity.



线程安全性

两个线程同时对同一个字符串进行操作的话，是不可能线程安全的，出于性能考虑, C++并没有为string实现线程安全， 毕竟不是所有程序都要用到多线程。

但是两个线程同时对独立的两个string操作时，必须是安全的。COW技术实现这一点是通过原子的对引用计数进行+1或-1操作。

CPU的原子操作虽然比mutex锁好多了, 但是仍然会带来性能损失, 原因如下:

  • 阻止了CPU的乱性执行
  • 两个CPU对同一个地址进行原子操作，会导致cache失效, 从而重新从内存中读数据.
  • 系统通常会lock住比目标地址更大的一片区域，影响逻辑上不相关的地址访问

这也是在多核时代，各大编译器厂商都选择了SS0实现的原因。



COW 写时复制的代码实现

思路1：写时复制基本实现

#include <stdio.h>
#include <string.h>
#include <iostream>

using std::endl;
using std::cout;

class String
{
public:
    String()
    : _pstr(new char[5]() + 4) //留出4字节存放引用计数, 1字节存放'\0'，+4即偏移到数据的位置
    {
        cout << "String()" << endl;
        initRefcount();
    }

    String(const char *pstr)
    : _pstr(new char[strlen(pstr) + 5]() + 4) //申请数据+5(引用计数)的空间，指针偏移到数据的位置
    {
        cout << "String(const char *pstr)" << endl;
        strcpy(_pstr, pstr);
        initRefcount();
    }

    String(const String  &rhs)
    : _pstr(rhs._pstr)
    {
        cout << "String(const String  &rhs)" << endl;
        increRefcount();
    }

    String & operator=(const String &rhs)
    {
        cout << "String & operator=(const String &rhs)" << endl;
        if(this != &rhs)//防止自复制
        {
            releaseFunc(); // 释放左操作数
            _pstr = rhs._pstr; //浅拷贝
            increRefcount();
        }
        return *this; // 返回*this
    }

    char & operator[](size_t idx)
    {
        if(idx < size())
        {
            if(getRefcount() > 1) //引用计数不是最后一个
            {
                char * ptmp = new char[size() + 5]() + 4;
                strcpy(ptmp, _pstr);
                decreRefcount();
                _pstr = ptmp;
                initRefcount();
            }
            return _pstr[idx];
        }
        else
        {
            static char nullchar = '\0';
            return nullchar;
        }
    }

    ~String()
    {
        cout << "~String()" << endl;
        releaseFunc();
    }

public:
    //获取引用计数
    int getRefcount() const
    {
        return *(int *)(_pstr - 4);
    }

    //转C风格字符串
    const char * c_str() const
    {
        return _pstr;
    }

    //字符串大小
    size_t size() const
    {
        return strlen(_pstr);
    }

private:

    //初始化引用计数
    void initRefcount()
    {
        // 引用计数初始化为1
        // (pstr - 4) 指针回到堆起始位置（引用计数起始位置）
        // (int *) 强转为 int*指针类型
        // *(int *)(pstr - 4) 解引用
        // *(int *)(pstr - 4) = 1 初始化为1
        
        *(int *)(_pstr - 4) = 1;
    }

    //引用计数自增
    void increRefcount()
    {
        ++*(int *)(_pstr - 4);
    }

    //引用计数自减
    void decreRefcount()
    {
        --*(int *)(_pstr - 4);
    }
    
    //堆空间释放
    void releaseFunc()
    {
        decreRefcount();
        if(getRefcount() == 0)
        {
            delete [] (_pstr - 4);
        }
    }

    friend std::ostream &operator<<(std::ostream &os, const String &rhs);

private:
    char * _pstr;
};

std::ostream & operator<<(std::ostream &os, const String &rhs)
{
    os << rhs._pstr;
    return os;
}

void test()
{
    String s1 = "Hello"; 
    String s2 = s1;
    cout << "s1 = " << s1 << endl;
    cout << "s2 = " << s2 << endl;
    cout << "s1 count is " << s1.getRefcount() << endl;
    cout << "s2 count is " << s2.getRefcount() << endl;
    printf("s1 address is %p\n", s1.c_str());
    printf("s2 address is %p\n", s2.c_str());
    
    //调用拷贝构造函数
    cout << endl;
    String s3("world");
    s3 = s1; 
    cout << "s1 = " << s1 << endl;
    cout << "s2 = " << s2 << endl;
    cout << "s3 = " << s3 << endl;
    cout << "s1 count is " << s1.getRefcount() << endl;
    cout << "s2 count is " << s2.getRefcount() << endl;
    cout << "s3 count is " << s3.getRefcount() << endl;
    printf("s1 address is %p\n", s1.c_str());
    printf("s2 address is %p\n", s2.c_str());
    printf("s3 address is %p\n", s3.c_str());

    //写时复制
    cout << endl;
    cout << "s3[0]写操作: s3[0] = 'h'" << endl;
    s3[0] = 'h';
    cout << "s1 = " << s1 << endl;
    cout << "s2 = " << s2 << endl;
    cout << "s3 = " << s3 << endl;
    cout << "s1 count is " << s1.getRefcount() << endl;
    cout << "s2 count is " << s2.getRefcount() << endl;
    cout << "s3 count is " << s3.getRefcount() << endl;
    printf("s1 address is %p\n", s1.c_str());
    printf("s2 address is %p\n", s2.c_str());
    printf("s3 address is %p\n", s3.c_str());

    //读操作（出错）
    cout << endl;
    cout << "s1[0]读操作" << endl;
    cout << "s1[0] = " << s1[0] << endl;
    cout << "s1 = " << s1 << endl;
    cout << "s2 = " << s2 << endl;
    cout << "s3 = " << s3 << endl;
    cout << "s1 count is " << s1.getRefcount() << endl;
    cout << "s2 count is " << s2.getRefcount() << endl;
    cout << "s3 count is " << s3.getRefcount() << endl;
    printf("s1 address is %p\n", s1.c_str());
    printf("s2 address is %p\n", s2.c_str());
    printf("s3 address is %p\n", s3.c_str());
}

int main()
{
    test();
    return 0;
}

上面的代码已经基本实现了 写时复制，但是经过过运行就可以发现一点错误，因为读操作还是有问题，没有区分下标运算符的读写操作，引用计数出错
在这里插入图片描述
于是我们就需要进行修改，区分下标运算符是赋值还是输出流，但是下标运算符重载的返回值为char内置类型，无法进行重载，于是我们就 重新定义一个类，让这个类为我们区分下标运算符是赋值还是输出流，分别实现下标运算符的赋值和下标运算符的输出流。

这样的方法也叫做 代理模式

代理模式：为其他对象提供一种代理以控制对这个对象的访问。
代理者：一个类别可以作为其它东西的接口

思路2：代理模式实现读写操作

#include <stdio.h>
#include <string.h>
#include <iostream>

using std::endl;
using std::cout;


class String
{
public:
    String()
    : _pstr(new char[5]() + 4) //留出4字节存放引用计数, 1字节存放'\0'，+4 即偏移到数据的位置
    {
        cout << "String()" << endl;
        initRefcount();
    }

    String(const char *pstr)
    : _pstr(new char[strlen(pstr) + 5]() + 4) //申请数据+5(引用计数)的空间，指针偏移到数据的位置
    {
        cout << "String(const char *pstr)" << endl;
        strcpy(_pstr, pstr);
        initRefcount();
    }

    String(const String  &rhs)
    : _pstr(rhs._pstr)
    {
        cout << "String(const String  &rhs)" << endl;
        increRefcount();
    }

    String & operator=(const String &rhs)
    {
        cout << "String & operator=(const String &rhs)" << endl;
        if(this != &rhs)//防止自复制
        {
            releaseFunc(); // 释放左操作数
            _pstr = rhs._pstr; //浅拷贝
            increRefcount();
        }
        return *this; // 返回*this
    }

private:
    //设计模式之代理模式
    //区分(代理)下标运算符是赋值还是输出流
    //操作String的类
    class Char
    {
    public:
        Char(String & self, size_t idx)//不加const的原因，有写操作
        : _self(self)
        , _idx(idx)
        {
            cout << "Char()" << endl;
        }
        
        char & operator=(const char &ch);
        friend std::ostream & operator<<(std::ostream &os, const Char &rhs);

    private:
        String & _self;
        size_t _idx;
    };

public:
    //char 不能重载，区分赋值和输出流，返回定义的自定义类型
    Char operator[](size_t idx) //去掉引用，不能返回局部变量的引用
    {
        return Char(*this, idx);
    }

    ~String()
    {
        cout << "~String()" << endl;
        releaseFunc();
    }

public:
    //获取引用计数
    int getRefcount() const
    {
        return *(int *)(_pstr - 4);
    }

    //转C风格字符串
    const char * c_str() const
    {
        return _pstr;
    }

    //字符串大小
    size_t size() const
    {
        return strlen(_pstr);
    }

private:

    //初始化引用计数
    void initRefcount()
    {
        // 引用计数初始化为1
        // (pstr - 4) 指针回到堆起始位置（引用计数起始位置）
        // (int *) 强转为 int*指针类型
        // *(int *)(pstr - 4) 解引用
        // *(int *)(pstr - 4) = 1 初始化为1
        
        *(int *)(_pstr - 4) = 1;
    }

    //引用计数自增
    void increRefcount()
    {
        ++*(int *)(_pstr - 4);
    }

    //引用计数自减
    void decreRefcount()
    {
        --*(int *)(_pstr - 4);
    }
    
    //堆空间释放
    void releaseFunc()
    {
        decreRefcount();
        if(getRefcount() == 0)
        {
            delete [] (_pstr - 4);
        }
    }

    friend std::ostream &operator<<(std::ostream &os, const String &rhs);
    
    friend std::ostream & operator<<(std::ostream &os, const Char &rhs);

private:
    char * _pstr;
};

std::ostream & operator<<(std::ostream &os, const String &rhs)
{
    os << rhs._pstr;
    return os;
}


char & String::Char::operator=(const char &ch)
{
    if(_idx < _self.size())
    {
        if(_self.getRefcount() > 1) //引用计数不是最后一个
        {
            char * ptmp = new char[_self.size() + 5]() + 4;
            strcpy(ptmp, _self._pstr);
            _self.decreRefcount();
            _self._pstr = ptmp;
            _self.initRefcount();
        }
        _self._pstr[_idx] = ch; //赋值
        return _self._pstr[_idx];
    }
    else
    {
        static char nullchar = '\0';
        return nullchar;
    }
}

std::ostream & operator<<(std::ostream &os, const String::Char &rhs)
{
    os << rhs._self._pstr[rhs._idx];
    return os;
}

void test()
{
    //...同思路1
}


int main()
{
    test();
    return 0;
}

在这里插入图片描述
现在已经基本完成，还有一点小细节进行优化，就是输出流运算符的重载，其实可以去掉，可以直接在代理类中将 Char 转换为 char 类型 ，就可以直接输出到输出流，无需重载输出流运算符

修改代码，删除掉输出流运算符的重载，直接operator char()转换，return 数据即可

//设计模式之代理模式
//区分(代理)下标运算符是赋值还是输出流
//操作String的类
class Char
{
public:
    Char(String & self, size_t idx)//不加const的原因，有写操作
    : _self(self)
    , _idx(idx)
    {
        cout << "Char()" << endl;
    }
    
    char & operator=(const char &ch);

    //friend std::ostream & operator<<(std::ostream &os, const Char &rhs);
    //Char转换为char类型，就可以直接输出到输出流（<<可以识别的类型）
    operator char()
    {
        return _self._pstr[_idx];
    }

private:
    String & _self;
    size_t _idx;
};
Yol_2626
关注
  • 9
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
探究C++中string类的实现原理以及扩展使用
09-03
首先，`std::string`是C++标准库中的`std::basic_string`模板类的特化版本，用于处理UTF-8编码的ASCII或宽字符`wchar_t`的字符串。`std::string`的定义如下： ```cpp typedef basic_string, char_traits, allocator...
【STL源代码】C++标准库STL源代码下载
09-05
STL，全称为Standard Template Library，是C++标准库的核心部分，它提供了一组高效、通用的容器、迭代器、算法和函数对象。在【STL源代码】中，我们可以深入学习并理解这些组件的实现细节，从而提高编程技能和效率。...
【C++】深度剖析string类的底层结构及其模拟实现
m0_70980326的博客
04-13 2047
深度剖析string类的底层结构及其模拟实现
探秘PLCT实验室：WeloveInterns——编程新星的摇篮
gitblog_00020的博客
05-21 411
探秘PLCT实验室：WeloveInterns——编程新星的摇篮 项目地址:https://gitcode.com/lazyparser/weloveinterns 项目介绍 weloveinterns 是一个由中国科学院软件研究所下属的PLCT实验室创建的开源项目，旨在为对编译技术充满热情的学生和开发者提供实习机会和成长平台。这个项目不仅涵盖了实习职位的信息，还包括了实验室的文化、管理和人才培养...
[C++] C++标准库中的string类的使用(上)、
lcc11223的博客
08-10 1723
目录简单了解C++标准库中的string类1、为什么学习C++标准库中的 string 类？1.1、C语言中的字符串2、C++标准库中的 string 类3、C++标准库中string类的类体中已显示实现的常见的类成员函数接口3.1、构造函数(包括拷贝构造函数)3.2、析构函数3.3、赋值运算符重载函数3.4、C++标准库中的string类所实例化出的对象的访问及遍历操作3.4.1、方法一：下标+运算符[ ]的运算符重载 、3.4.2、方法二：迭代器 、3.4.3、方法三：范围for(语法糖) 、
Hello C++（九）——C++标准库简介
天山老妖
02-22 2104
一、C++标准库简介 1、C++标准库简介 C++标准库（C++ Standard Library），是类库和函数的集合。 C++编译器厂商根据C++标准委员会官方的ISO规范并将其转化为代码。C++编译器厂商在实现C++标准库过程中必须依赖其不同操作系统所提供的系统调用接口，因此每个平台都有其自己的C++标准库实现。 C++标准库的特点如下： A、C++标准库不是C++语言标准的一部分，由类库和函数库组成。 B、C++标准库中定义的类和对象都位于std命名空间中。 C、C++标准库的头文件.
C++STL库：String介绍
weixin_43654363的博客
07-15 1152
C++数据结构专题之：C++STL库的String介绍与泛型实现原理
C++标准模板库--string类
aiyubaobei的博客
03-13 1804
c++中string类的一些常用函数
【C++】vector的底层原理及实现
最新发布
炸掉地球的博客
07-03 1340
我们的目的不是去模拟实现vector，而是更深入地理解vector的底层原理，更好地提升自己。本篇将简单地模拟实现vector，更好地理解它的构造和原理。在C++的STL中，vector是最常用的容器之一，底层是一段连续的线性内存空间（泛型的动态类型顺序表），可以支持随机访问。vector可以存储各种类型，int、char、string等，所以它是一种类模板，可以套用各种类型。
C++中的string类详解
Weirdo的博客
06-04 1167
类是C++标准库中用于处理字符串的重要工具。它提供了丰富的成员函数和操作符重载，使得字符串操作变得简单而高效。本文详细介绍了类的基本概念、构造函数、常用成员函数、操作符重载以及其他功能，并通过示例代码展示了其常见用法。希望这些内容能够帮助读者更好地理解和使用类进行字符串处理。
【C++】list的使用及底层实现原理
weixin_67596609的博客
07-17 2131
本篇文章对list的使用进行了举例讲解。同时也对底层实现进行了讲解。底层的实现关键在于迭代器的实现。希望本篇文章会对你有所帮助。list底层实现关键是迭代器的实现。我们要清楚的是，list的迭代器底层就是一个对节点进行封装的类。初学可能会感觉有点难以理解。但是，应多看几遍理解整体结构就很容易清楚了。
C++标准模板库STL---string类
qq_52363432的博客
03-06 1405
STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
C++标准模板库map的常用操作
08-26
C++标准模板库map是一种关联式容器，以key-value的形式存储，以红黑树（平衡二叉查找树）作为底层数据结构，对数据有自动排序的功能。命名空间为std，所属头文件为。 一、map的基本信息 * map的容量：map.size()，...
c++ 标准库
05-28
值得注意的是，`bitset`（位集）和`string`（字符串）也可以被视为C++标准库的一部分，尽管它们在分类上并不属于以上三类。 #### 常见类型别名（Common Typedefs） 大多数序列容器和关联容器定义了以下类型的类型...
C++中sting类的简单实现方法
09-01
在C++编程中，`std::string`是一个非常重要的类，用于处理...在实际项目中，通常会使用标准库提供的`std::string`，因为它经过优化，具有更好的性能和安全性。然而，理解自定义实现的过程对于提升编程技能大有裨益。
C++基础之函数重载和默认参数
yolan2626的博客
04-15 3235
主要介绍：函数重载，nm指令查看编译，C/C++混合编程，默认参数的目的，默认参数的声明，默认参数的顺序规定，默认参数与函数重载（易错） ，默认参数的注意点
Linux设置进程CPU亲和力（核心绑定）
yolan2626的博客
12-24 2190
通过 sched_setaffinity 函数，利用 CPU 亲和性，将自己的多进程程序和多个 CPU核 心绑定，优化 CPU 使用
C++类和对象之创建销毁对象和初始化列表
yolan2626的博客
04-18 1579
主要介绍：对象的创建（构造函数），初始化表达式，对象的销毁（析构函数）
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值