我可以超载 CArchive <<运算符与 std::string 一起使用吗？

Question

我在 MFC 应用程序中使用 std::string ，我想将其存储在 doc 的 Serialize() 函数中。我不想将它们存储为 CString，因为它在其中写入自己的内容，我的目标是创建一个我知道其格式并且可以由其他应用程序读取的文件，而无需 CString。所以我想将我的 std::strings 存储为 4 个字节（int）字符串长度，后跟包含该字符串的该大小的缓冲区。

void CMyDoc::Serialize(CArchive& ar)
{
    std::string theString;

    if (ar.IsStoring())
    {
        // TODO: add storing code here
        int size = theString.size();
        ar << size;
        ar.Write( theString.c_str(), size );

    }
    else
    {
        // TODO: add loading code here
        int size = 0;
        ar >> size;
        char * bfr = new char[ size ];
        ar.Read( bfr, size);
        theString = bfr;
        delete [] bfr;
    }
}

上面的代码不太好，我必须分配一个临时 bfr 来读取字符串。首先，我可以直接将字符串读入 std::string 而不使用临时缓冲区吗？其次，我可以超载<<吗？ std::string / CArchive 的缓冲区，因此我可以简单地使用 ar <<字符串？总的来说，有没有更好的方法使用 CArchive 对象读取/写入 std::string ？

Answer 1

您可以从 stl 字符串构建一个就地 CString 并将其序列化。例如：

CString c_string(my_stl_string.c_str();
ar << c_string;

您可以将其放入全局操作员重载中，这样您就可以

ar << my_c_string;

从任何地方进行操作，例如：

CArchive& operator<<(CArchive rhs, string lhs) {
    CString c_string(lhs.c_str());
    rhs << c_string;
}

Answer 2

尝试：

theString.resize(size);
ar.Read(&theString[0], size);

从技术上讲，&theString[0] 不能保证指向连续的字符缓冲区，但 C++ 委员会进行了一项调查，发现所有现有的实现都是这样工作的。

Answer 3

由于各种原因，将数据写为 CString 可能会更好，但是如果您必须将 String (m_sString) 转换为 ASCII 字符串，也许这样的东西适合您......

void myclass::Serialize(CArchive & ar)
{
    CHAR* buf;
    DWORD len;
    if (ar.IsStoring()) // Writing
    {
        len = m_sString.GetLength(); // Instead of null terminated string, store size.
        ar << len;
        buf = (CHAR*)malloc(len);
        WideCharToMultiByte(CP_UTF8, 0, m_sString, len, buf, len, NULL, NULL); // Convert wide to single bytes
        ar.Write(buf, len); // Write ascii chars
        free(buf);
    }
    else // Reading
    {
        ar >> len;
        buf = (CHAR*)malloc(len);
        ar.Read(buf, len); // Read ascii string
        MultiByteToWideChar(CP_UTF8, 0, buf, len, m_sString.GetBufferSetLength(len), len); // Convert ascii bytes to CString wide bytes
        free(buf);
    }
}

Answer 4

只是为 std::string 和 std::wstring 添加一个功能齐全且正确的示例（希望如此）：

#include <string>
#include <gsl/gsl>

template <typename Char>
CArchive& operator<<(CArchive& ar, const std::basic_string<Char>& rhs)
{
    const auto size = rhs.size();
    ar << size;
    ar.Write(rhs.data(), gsl::narrow_cast<UINT>(size) * sizeof(Char));
    return ar;
}

template <typename Char>
CArchive& operator>>(CArchive& ar, std::basic_string<Char>& rhs)
{
    size_t size{};
    ar >> size;
    rhs.resize(size);
    ar.Read(rhs.data(), gsl::narrow_cast<UINT>(size) * sizeof(Char));
    return ar;
}

写作...

std::wstring ws{ L"wide string" };
ar << ws;

std::string ns{ L"narrow string" };
ar << ns;

阅读...

std::wstring ws;
ar >> ws;

std::string ns;
ar >> ns;

Answer 5

如果您使用的库仅适用于 c 样式字符串，则无法安全 直接写入 std::string。该问题已在 C++0x 中修复。
所以像这样的东西

// NOT PORTABLE, don't do this
theString.resize(size);
ar.Read( const_cast<char *>(theString.c_str(), size);

可能会起作用，但它可能会在以后产生一些微妙的、难以跟踪的错误。
当然，您的问题意味着您已经分析了代码并发现创建缓冲区并复制数据两次实际上是代码中的瓶颈。如果还没有，那么您不必担心效率低下。

Answer 6

我想您可能会违反 STL 准则并继承 std::string 并添加您自己的缓冲区 getter/setter。然后重写 std::string 的复制构造函数并转移缓冲区的所有权。