当调用'string:：c_str（）'时，实际会执行什么操作？

Question

调用string:：c_str（）时，实际会执行什么操作？

1. 字符串::c_str（）将分配内存，复制字符串对象的内部数据并在新分配的内存中追加一个以null结尾的字符？

或者

在这个问题的答案的评论中有人说，C11要求std:：string为后面的'\0'分配一个额外的char。因此，第二种选择似乎是可能的。

另一个人说，std:：string操作——例如迭代、串联和元素突变——不需要零终止符。除非将字符串传递给需要以零结尾的字符串的函数，否则可以忽略该字符串。

为什么实现者通常让. data（）和.c_str（）做同样的事情？

因为这样做效率更高。这是唯一的办法。data（）返回不以null结尾的内容，这将是必须的。c_str（）或。data（）复制它们的内部缓冲区，或者只使用两个缓冲区。拥有一个以null结尾的缓冲区总是意味着在实现std:：string时，始终可以只使用一个内部缓冲区。

所以我现在真的很困惑，当调用string:：c_str（）时，实际会做什么？

更新：

如果c_str（）实现为简单地返回指针，则它已经被分配和管理。

A.由于c_str（）必须以null结尾，因此内部缓冲区需要始终以null结尾，即使对于空的std:：string，例如：std:：string demo_str；，demo_str的内存中应该有一个\0。我说得对吗？

B.调用std:：string:：substr（）时会发生什么？自动将\0附加到子字符串？

Answer 1

我们已经提供了很多很好的答案和评论。但是为了证明std:：string通常由以null结尾的字符串支持，我提供了一个简单但幼稚的实现。它不完整，不进行错误检查，当然也没有优化。但它已经足够完整，可以向您展示字符串类通常是如何使用以null结尾的缓冲区作为成员变量来实现的。

class string
{
public:

    string()
    {
        assign("", 0);
    }

    string(const char* s)
    {
        assign(s, strlen(s));
    }

    string(const char* s, size_t len)
    {
        assign(s, len);
    }

    string(const string& s)
    {
        assign(s._ptr, s._len);
    }

    ~string()
    {
       delete [] _ptr;
    }

    string& operator=(const string& s)
    {
        const char* oldptr = _ptr;
        assign(s._ptr, s._len);
        delete [] oldptr;
    }

    const char* data()
    {
        return _ptr;
    }

    const char* c_str()
    {
       return _ptr;
    }

    size_t length()
    {
        return _len;
    }

    // substr always returns a new string
    std::string substr(size_t pos, size_t count)
    {
        std::string s(_ptr+pos, count);
        return s;  
    }

private:
    char* _ptr;
    size_t _len;

    void assign(const char* ptr, size_t len)
    {
        _len = len;        
        _ptr = new char[_len+1]; // +1 for null termination
        memcpy(_ptr, ptr, len); 
        _ptr[_len] = '\0';       // always null terminate
    }
};

Answer 2

这里有一个经验“证明”的复杂性。c_str（）是o（1）：

#include <stdio.h>
#include <string>
using namespace std;
int main(int argc, char **argv)
{
    std::string x(5000000, 'b'); // <--- single time allocation
    // std::string x(5, 'b'); // <--- compare to a much shorter string
    for (unsigned int i=0;i<1000000;i++)
    {
        const char *y = x.c_str(); // <--- copy entire content ?
    }
}

• 使用-O0编译以避免优化任何内容
• 计时2个版本：我获得相同的性能
• 这是一个经验“证明”（至少我的机器的实现）
  • 提取以null结尾的字符串的内部表示形式
  • 不会每次都复制内容。调用c_str（）

Answer 3

由于C11，std::字符串::c_str（）和std::字符串::data（）都需要返回指向字符串内部缓冲区的指针。由于c_str（）（但不是data（））必须以null结尾，这实际上要求内部缓冲区始终以null结尾，尽管null终止符不按size（）/long（）计数，也不按std::字符串迭代器等返回。

在C11之前，c_str（）的行为在技术上是特定于实现的，但是我见过的大多数实现都是这样工作的，因为这是实现它的最简单和最明智的方法。C11只是标准化了已经广泛使用的行为。

使现代化

从C 11开始，缓冲区总是以null结尾，即使对于空字符串也是如此。然而，这并不意味着当字符串为空时需要动态分配缓冲区。它可以指向SSO缓冲区，甚至可以指向单个静态nul字符。无法保证字符串内容更改时，c_str（）/data（）返回的指针仍指向同一内存地址。

std:：string:：substr（）返回一个新的std:：string，它有自己的以null结尾的缓冲区。从中复制的字符串不受影响。