使用隐式转换为 char* (C++) 实现 String 类

Question

根据我在几个地方读到的内容，这可能是不可取的（这可能是 std::string 尚未这样做的原因），但在受控环境和谨慎使用的情况下，我认为它可能可以编写一个字符串类，当第三方库方法（仅接受 char* 作为参数）需要时，该类可以隐式转换为适当的可写字符缓冲区，并且仍然表现得像具有 Find() 等方法的现代字符串、Split()、SubString() 等。虽然稍后我可以尝试实现通常的其他字符串操作方法，但我首先想问一下执行此主要任务的高效且安全的方法。目前，我们必须分配一个大约为第三方方法预期的 char* 输出的最大大小的 char 数组，将其传递到那里，然后将返回的 char* 转换为 std::string 以便能够使用它允许使用方便的方法，然后再次使用 string.c_str() 将其 (const char*) 结果传递给另一个方法。这既冗长又使代码看起来有点混乱。

到目前为止，这是我最初的实现：

MyString.h

#pragma once
#include<string>

using namespace std;

class MyString
{
private:
    bool mBufferInitialized;
    size_t mAllocSize;
    string mString;
    char *mBuffer;

public:
    MyString(size_t size);
    MyString(const char* cstr);
    MyString();
    ~MyString();
    operator char*() { return GetBuffer(); }
    operator const char*() { return GetAsConstChar(); }
    const char* GetAsConstChar() { InvalidateBuffer(); return mString.c_str(); }

private:
    char* GetBuffer();
    void InvalidateBuffer();
};

MyString.cpp

#include "MyString.h"

MyString::MyString(size_t size)
    :mAllocSize(size)
    ,mBufferInitialized(false)
    ,mBuffer(nullptr)
{
    mString.reserve(size);
}

MyString::MyString(const char * cstr)
    :MyString()
{
    mString.assign(cstr);
}

MyString::MyString()
    :MyString((size_t)1024)
{
}

MyString::~MyString()
{
    if (mBufferInitialized)
        delete[] mBuffer;
}

char * MyString::GetBuffer()
{
    if (!mBufferInitialized)
    {
        mBuffer = new char[mAllocSize]{ '\0' };
        mBufferInitialized = true;
    }

    if (mString.length() > 0)
        memcpy(mBuffer, mString.c_str(), mString.length());

    return mBuffer;
}

void MyString::InvalidateBuffer()
{
    if (mBufferInitialized && mBuffer && strlen(mBuffer) > 0)
    {
        mString.assign(mBuffer);
        mBuffer[0] = '\0';
    }
}

示例用法（main.cpp）

#include "MyString.h"
#include <iostream>

void testSetChars(char * name)
{
    if (!name)
        return;
    //This length is not known to us, but the maximum 
    //return length is known for each function. 
    char str[] = "random random name";
    strcpy_s(name, strlen(str) + 1, str);
}


int main(int, char*)
{
    MyString cs("test initializer");
    cout << cs.GetAsConstChar() << '\n';
    testSetChars(cs);
    cout << cs.GetAsConstChar() << '\n';
    getchar();
    return 0;
}

现在，我计划在执行任何其他操作之前在几乎所有方法中调用 InvalidateBuffer()。现在我的一些问题是：

1. 在内存/性能和/或安全性方面是否有更好的方法，尤其是在 C++ 11 中（除了我计划很快添加到其中的通常的移动构造函数/赋值运算符）？
2. 我最初使用字符的 std::vector 实现了“缓冲区”，它更容易实现并且更像 C++，但担心性能。所以 GetBuffer() 方法只会返回调整大小的向量的开始指针。您认为在这里使用向量而不是 char* 有什么主要的优点/缺点吗？
3. 我计划稍后为其添加宽字符支持。你认为两个结构的 union ： {char,string} 和 {wchar_t, wstring} 将是实现该目的的方式（一次只能是这两个结构中的一个）？
4. 是否过于矫枉过正，而不仅仅是按照通常的方式传递 char 数组指针，转换为 std::string 并使用它来完成我们的工作。期望 char* 参数的第三方函数调用在代码中被大量使用，如果它有效，我计划用这个新字符串完全替换 char* 和 std::string。

感谢您的耐心和帮助！

Answer 1

如果我对您的理解正确，您希望它能够正常工作：

mystring foo;
c_function(foo);
// use the filled foo

c_function 喜欢 ...

void c_function(char * dest) {
  strcpy(dest, "FOOOOO");
}

相反，我建议 (ideone example)：

template<std::size_t max>
struct string_filler {
  char data[max+1];
  std::string & destination;
  string_filler(std::string & d) : destination(d) {
    data[0] = '\0'; // paranoia
  }
  ~string_filler() {
    destination = data;
  }
  operator char *() {
    return data;
  }
};

并像这样使用它：

std::string foo;
c_function(string_filler<80>{foo});

通过这种方式，您可以为 C 函数提供一个“正常”缓冲区，其最大值由您指定（无论哪种方式您都应该知道......否则调用该函数将是不安全的）。在销毁临时（根据标准，必须在函数调用的表达式之后发生）时，字符串被复制（使用std::string 赋值运算符）到由std::string 管理的缓冲区中。

---

解决您的问题：

您认为在这里使用向量而不是 char* 有什么主要优点/缺点吗？

是的：使用向量可以将您从手动内存管理中解放出来。这是一个巨大的专业人士。

我计划稍后为其添加宽字符支持。你认为两个结构的联合： {char,string} 和 {wchar_t, wstring} 将是实现该目的的方式（一次只能是这两个结构之一）？

工会是个坏主意。你怎么知道哪个成员当前处于活动状态？你需要一个工会以外的旗帜。你真的希望每根弦都能随身携带吗？而是看看标准库在做什么：它使用模板来提供这种抽象。

是不是太过分了[..]

编写字符串类？ 是的，太多了。

Answer 2

你想做的已经存在。例如，使用这个普通的旧 C 函数：

/**
 * Write n characters into buffer.
 * n cann't be more than size
 * Return number of written characters
 */
ssize_t fillString(char * buffer, ssize_t size);

C++11 起：

std::string str;
// Resize string to be sure to have memory
str.resize(80);
auto newSize = fillSrting(&str[0], str.size());
str.resize(newSize);

或不先调整大小：

std::string str;
if (!str.empty()) // To avoid UB
{
    auto newSize = fillSrting(&str[0], str.size());
    str.resize(newSize);
}

但在 C++11 之前，std::string 不能保证存储在单个连续内存块中。所以你必须先通过std::vector<char>；

std::vector<char> v;
// Resize string to be sure to have memor
v.resize(80);
ssize_t newSize = fillSrting(&v[0], v.size());

std::string str(v.begin(), v.begin() + newSize);

您可以轻松地将它与丹尼尔的命题一起使用