C++ 这些代码是否泄漏内存（在无限循环中构造stl列表）？

我制作了一个示例程序来研究以本地方式定义大量stl对象是否会泄漏内存或超出堆栈大小。 “g_list”是一个全局列表，从其他线程中吸收了一些元素。请不要关心线程互斥体、锁或其他东西（因为互斥体和锁总是吸引人的，不是吗？），只需在这个循环中附加这一行“list rawDataList=g_list”，每次都会构造一个列表，但不会超出它的范围，因为它处于无限循环中

• 这里没有“新”的rawDataList，它是一个局部变量，不是动态分配的，我指的是列表本身，而不是其中的元素
• 我们很清楚，“清除”和“弹出式”将破坏列表中的元素
• 我运行这段代码7个小时，并通过顶部工具查看它，内存量相当稳定，没有泄漏迹象 我的问题:
• 每次我们通过调用“list rawDataList”构造，甚至为其分配一些内容，但构造的列表永远不会超出范围，因此永远不会被销毁，尽管它的元素在每个循环中都会被销毁，但list对象始终驻留在内存（堆栈区域）中，当我们循环百万次时，堆栈怎么能包含这么多对象
• 并且，当第二次执行“list rawDataList=g_list”时，在第一次构造的list对象（它们具有相同的名称“rawDataList”）在哪里
• 为什么这个程序的内存没有泄漏

以下是代码：

    element e;  
    printf("in Cstlmem2::svc \n");
    int i =0;
    while(1){   
          pthread_mutex_lock(&m_mutex);
          while (g_list.empty()) // 为空，等待信号
          {
              pthread_cond_wait(&m_cond,&m_mutex);
          }

          list<element> rawDataList = g_list;
          g_list.clear();
          pthread_mutex_unlock(&m_mutex);

        while (!rawDataList.empty())
        {
            e = rawDataList.front();
            rawDataList.pop_front();

            int i = 0;
            while(i <1000000){
                i++;
            }

            printf("working in Cstlmem2::svc \n");
        }           
    }

元素e；
printf（“在cstlem2:：svc\n中”）；
int i=0；
而第（1）款{
pthread_mutex_lock（&m_mutex）；
while（g_list.empty（））//为空，等待信号
{
pthread_cond_wait（&m_cond，&m_mutex）；
}
list rawDataList=g_list；
g_list.clear（）；
pthread_mutex_unlock（&m_mutex）；
而（！rawDataList.empty（））
{
e=rawDataList.front（）；
rawDataList.pop_front（）；
int i=0；
虽然（i每当无限循环重复时，
rawDataList
的范围就会结束。旧列表会被销毁。在下一次迭代中，可能会在同一堆栈槽中创建一个新列表。
每当无限循环重复时，
rawDataList
的范围就会结束。旧列表会被销毁。在下一次迭代中，会创建一个新列表，pr可能在同一堆栈槽中。
每当无限循环重复时，
rawDataList
的范围结束。旧列表被销毁。在下一次迭代中，可能在同一堆栈槽中创建一个新列表。
每当无限循环重复时，
rawDataList
的范围结束。旧列表被销毁。在下一次iter上然后，可能在同一个堆栈槽中创建一个新对象。
我的回答是：这是关于作用域的，本地对象在离开其作用域时被销毁。
示例代码：
int x=0；
而（x<2）{
printf（“x是%d\n”，x）；
元素e1；

x++

    if (2 == x){
         while(1){
            sleep(1000);//do not leave the loop
            }
        }

    }

输出（我在构造函数和析构函数中打印一些内容）：
x是0
构造元素
destruct~元素——注意：它在“x是1”之前
x是1
construct元素
我的答案是：它是关于作用域的，本地对象在离开其作用域时被销毁。
示例代码：
int x=0；
而（x<2）{
printf（“x是%d\n”，x）；
元素e1；

x++

    if (2 == x){
         while(1){
            sleep(1000);//do not leave the loop
            }
        }

    }

输出（我在构造函数和析构函数中打印一些内容）：
x是0
构造元素
destruct~元素——注意：它在“x是1”之前
x是1
construct元素
我的答案是：它是关于作用域的，本地对象在离开其作用域时被销毁。
示例代码：
int x=0；
而（x<2）{
printf（“x是%d\n”，x）；
元素e1；

x++

    if (2 == x){
         while(1){
            sleep(1000);//do not leave the loop
            }
        }

    }

输出（我在构造函数和析构函数中打印一些内容）：
x是0
构造元素
destruct~元素——注意：它在“x是1”之前
x是1
construct元素
我的答案是：它是关于作用域的，本地对象在离开其作用域时被销毁。
示例代码：
int x=0；
而（x<2）{
printf（“x是%d\n”，x）；
元素e1；

x++

    if (2 == x){
         while(1){
            sleep(1000);//do not leave the loop
            }
        }

    }

输出（我在构造函数和析构函数中打印一些内容）：
x是0
构造元素
destruct~元素——注意：它在“x是1”之前
x是1
构造元素
我不知道。我知道任何值得尊敬的编译器都会在（I<1000000）

时不经意地删除你的“延迟循环”（

）。tks，这些代码除了帮助我确定我的问题之外没有其他意义。我只是不希望这个线程运行得比将东西放入g_列表的线程快。但是sleep（）只有空闲时间至少大于1秒，这对我来说太多了。无论如何，如果需要的话，让我们不要看这些在posix平台上延迟的不必要的代码使用，不要依赖于那个循环。如果需要自旋锁，每个平台都已经实现了自旋锁。如果需要小于1秒，这是最好的选择。@Mgetz，th真的！甚至这不是我这篇文章的主要关注点。这个程序将
g_列表
复制到
rawDataList
，然后将其删除。这可以通过
swap
：
list rawDataList；g_list.swap（rawDataList）更有效地完成
。我不知道。我知道任何值得尊敬的编译器都会在（我<1000000）

的时候不客气地删除你的“延迟循环”（

）。tks，这些代码除了帮助我确定我的问题之外没有其他意义。我只是不希望这个线程运行得比把东西放入g_列表的线程快。但是sleep（）只会空闲至少超过1秒，这对我来说太多了。无论如何，如果需要的话，让我们不要看这些在posix平台上延迟的不必要的代码使用，不要依赖于那个循环。如果需要自旋锁