3

我从一个非常简单的程序开始：

#include <TBString.h>

int main(int argv, char** argc)
{
    tb::String test("");
    test = "Hello World!";

    return 0;
}

tb::String是我自己的字符串类，旨在处理char字符串和wchar_t（Unicode）字符串。它是大量模板化的，tb::String是tb::StringBase<char>.

整个过程是使用 CRT 调试实用程序编译的，以检查内存泄漏。这是输出：

Detected memory leaks!
Dumping objects ->
c:\users\sam\svn\dependencies\toolbox\headers\tbstring2.inl(38) : {442} normal block at 0x00D78290, 1 bytes long.
 Data: < > 00 
{131} normal block at 0x00C5EFA0, 52 bytes long.
 Data: <                > A0 EF C5 00 A0 EF C5 00 A0 EF C5 00 CD CD CD CD 
Object dump complete.
Detected memory leaks!
Dumping objects ->
c:\users\sam\svn\dependencies\toolbox\headers\tbstring2.inl(38) : {442} normal block at 0x00D78290, 1 bytes long.
 Data: < > 00 
Object dump complete.
The program '[2888] SAM_release.exe: Native' has exited with code 0 (0x0).

所以它看起来像一个空的 tb::String （大小为 0）导致内存泄漏。用这个程序确认，它不会泄漏：

#include <TBString.h>

int main(int argv, char** argc)
{
    tb::String test("Hello World!");

    return 0;
}

原始程序的调用堆栈：

  • StringBase<char>用字符串创建一个""。
  • m_Length设置为 0。
  • m_Maximum设置为m_Length + 1(1)。
  • m_Data创建长度为m_Maximum(1)。
  • m_Data被清除并充满""。
  • _AppendSingle设置为StringBase<char>::_AppendDynSingle。
  • 重载的运算符StringBase<char>::operator =用字符串调用"Hello World!"
  • _AppendSingle叫做。
  • m_Length为 0，m_Maximum为 1。
  • checklen设置为m_Length + src_len + 1(13)。
  • m_Maximum乘以 2 直到大于checklen(16)。
  • 使用新的最大值调用该StringBase<char>::Resize函数。

调整大小功能：

template <typename C>
TB_INLINE StringBase<C>& StringBase<C>::Resize(int a_Maximum /*= -1*/)
{
    if (!m_Data)
    {
        m_Maximum = (a_Maximum == -1) ? 4 : a_Maximum;
        m_Data = new C[m_Maximum];
        StringHelper::Clear<C>(m_Data, m_Maximum);
    }
    else
    {
        int newmax = (a_Maximum == -1) ? (m_Maximum * 2) : a_Maximum;

        C* temp = new C[newmax];
        StringHelper::Clear<C>(temp, newmax);
        if (m_Length > 0) { StringHelper::Copy(temp, m_Data, m_Length); }
        delete [] m_Data;
        m_Data = temp;

        m_Maximum = newmax;
    }

    return *this;
}

这是我怀疑的问题。现在，我的问题变成了：

如何在 C++ 中重新分配内存而不触发 CRT 调试器中的内存泄漏？

构造函数：

TB_INLINE StringBase<char>::StringBase(const char* a_String)
{
    m_Length = StringHelper::GetLength<char>(a_String);
    m_Maximum = m_Length + 1;
    m_Data = new char[m_Maximum];
    StringHelper::Clear<char>(m_Data, m_Maximum);

    StringHelper::Copy<char, char>(m_Data, a_String, m_Length);

    _AppendSingle = &StringBase<char>::_AppendDynSingle;
    _AppendDouble = &StringBase<char>::_AppendDynDouble;
}

析构函数：

TB_INLINE StringBase<char>::~StringBase()
{
    if (m_Data) { delete [] m_Data; }
}

赋值运算符：

TB_INLINE StringBase<char>& StringBase<char>::operator = (const char *a_String)
{
    Clear();
    return (this->*_AppendSingle)(a_String);
}

附加功能：

template<>
TB_INLINE StringBase<char>& StringBase<char>::_AppendDynSingle(const char* a_String)
{
    if (!a_String) { return *this; }

    int src_len = StringHelper::GetLength<char>(a_String);

    // check size

    if (m_Maximum == -1)
    {
        m_Maximum = src_len + 1;
        m_Data = new char[m_Maximum];
        StringHelper::Clear<char>(m_Data, m_Maximum);
        m_Length = 0;
    }

    int checklen = m_Length + src_len + 1;
    if (checklen > m_Maximum)
    {
        while (checklen > m_Maximum) { m_Maximum *= 2; }
        Resize(m_Maximum);
    }

    // append

    strcat(m_Data, a_String);

    // new length

    m_Length += src_len;

    return *this;
}

请注意：我不想使用std::stringor std::vector，我想修复这个功能。

4

2 回答 2

0

执行赋值后，您正在泄漏构造函数中初始化的任何字节。要调试泄漏，请在执行分配时使用调试器单步执行。在变量上设置观察点可能很有用，m_Data以便调试器在更改值时停止。

于 2012-06-12T11:35:59.447 回答
0

这将是一个漫长的过程。

首先，我决定检查我的理智。CRT 内存调试器是否正常工作？

int* src_test = new int[10];
for (int i = 0; i < 10; i++) { src_test[i] = i; }
int* dst_test = new int[10];
for (int i = 0; i < 10; i++) { dst_test[i] = src_test[i]; }
delete [] src_test;

这正确地报告了 40 个字节的泄漏。此行修复泄漏：

delete [] dst_test;

好吧，还有什么？好吧，也许解构器没有被调用。让我们把它放在一个函数中：

void ScopeTest()
{
    tb::String test("Hello World!");
    test = "Hello World! Again!";
}

它有效，但它会泄漏。让我们绝对确保调用了解构器。

void ScopeTest()
{
    tb::String* test = new tb::String("Hello World!");
    *test = "Hello World! Again!";
    delete test;
}

还在漏。那么，=运营商是做什么的呢？它清除并附加。让我们手动完成：

void ScopeTest()
{
    tb::String* test = new tb::String("Hello World!");
    test->Clear();
    test->Append("Hello World! Again!");
    delete test;
}

结果相同，因此与运算符无关。我想知道如果我删除了会发生什么Clear...

void ScopeTest()
{
    tb::String* test = new tb::String("Hello World!");
    test->Append("Hello World! Again!");
    delete test;
}

好吧，它……等等，什么？不漏吗？那做什么Clear呢？

template <>
TB_INLINE StringBase<char>& StringBase<char>::Clear()
{
    if (m_Data)
    {
        StringHelper::Clear<char>(m_Data, m_Maximum);
    }

    m_Length = 0;

    return *this;
}

那是……无害的。但是让我们把它注释掉。

template <>
TB_INLINE StringBase<char>& StringBase<char>::Clear()
{
    /*if (m_Data)
    {
        StringHelper::Clear<char>(m_Data, m_Maximum);
    }

    m_Length = 0;*/

    return *this;
}

结果相同，没有泄漏。让我们Clear再次删除调用。

void ScopeTest()
{
    tb::String* test = new tb::String("Hello World!");
    //test->Clear();
    test->Append("Hello World! Again!");
    delete test;
}

再次泄漏字节...

但是等一下，它还在清除tb::String? 长度设置为 0 并且数据清零，即使正文已被注释掉。怎么，什么……

好吧，编译器，让我们看看你编译这个：

/*template <>
TB_INLINE StringBase<char>& StringBase<char>::Clear()
{
    if (m_Data)
    {
        StringHelper::Clear<char>(m_Data, m_Maximum);
    }

    m_Length = 0;

    return *this;
}*/

哈！那会告诉他的！哦等等......它......仍然编译并运行。

我使用的是同一文件的不同版本吗？不，我只有一个版本的TBString2.handTBString2.inl在这台电脑上...

哦。

哦，等一下。

哦，该死的。

这最好不要像我想的那样。

Project Toolbox -> $(OutDir)\$(ProjectName)_d.lib

我要杀了那个为此花了三个小时的人。

Project Game -> Toolbox.lib

等一下。那是我。

TL;DR：我链接到一个旧版本的字符串类，导致各种奇怪的行为，包括内存泄漏。

于 2012-06-12T13:55:29.643 回答