C ++ статические классы и утечки памяти shared_ptr

Question

Я не могу понять, почему следующий код вызывает утечки памяти (я использую boost::shared_ptr с экземпляром статического класса).Может ли кто-нибудь мне помочь?

#include <crtdbg.h>
#include <boost/shared_ptr.hpp>
using boost::shared_ptr;

#define _CRTDBG_MAP_ALLOC
#define NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)

static struct myclass {
   static shared_ptr<int> ptr;

   myclass() {
      ptr = shared_ptr<int>(NEW int);
   }
} myclass_instance;

shared_ptr<int> myclass::ptr;

int main() {
   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF    | _CRTDBG_LEAK_CHECK_DF |
                  _CRTDBG_CHECK_ALWAYS_DF | _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG));
   return 0;
}

Answer 1

Это утечка памяти. Вы инициализируете статический экземпляр myclass с именем myclass_instance. Вы также инициализируете «shared_ptr myclass :: ptr».

Согласно Страуструпу [3], статика инициализируется в порядке их определения. Поэтому у вас есть статическое определение myclass_instance, которое инициализирует внутренний ptr при построении. Однако тогда у вас есть определение статического myclass :: ptr, которое вызывает конструктор по умолчанию для shared_ptr.

Это пример классической задачи упорядочения статики. Компилятор считает, что myclass :: ptr на самом деле не был инициализирован, поэтому нет уничтожения исходного shared_ptr. Вместо этого он просто просочился.

Вам понадобится какой-то голый указатель. Если вы используете C ++ 11, вы можете использовать Nifty Counter Technique с помощью троичного оператора присваивания, который перемещается сам по себе, если вы решите, что объект уже инициализирован. Это довольно грубо, но это работает.

Вот как я это сделаю в C ++ 11:

#include <crtdbg.h>
#include <memory>
using std;

#define _CRTDBG_MAP_ALLOC
#define NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)

// Note that the count could also be a field in an initializer static used in the Nifty Counter
// Technique covered in many texts.
static int count = 0; // This gets implicitly initialized to 0 by the executable load into memory.
static struct myclass {
   static shared_ptr<int> ptr;

   myclass() {
      if (count++ == 0) {
         ptr = make_shared<int>(0); //initialization
      }
   }          
} myclass_instance;

shared_ptr<int> myclass::ptr = count == 0 ? make_shared<int>(0) : move(myclass::ptr);

int main() {
   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF    | _CRTDBG_LEAK_CHECK_DF |
                  _CRTDBG_CHECK_ALWAYS_DF | _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG));
   return 0;
}

Для получения дополнительной информации см. Следующее:

1. Лакос, J, 1996, Разработка крупномасштабного программного обеспечения C ++. Раздел 7.8.1.3, Аддисон Уэсли, Рединг, Массачусетс.
2. Meyers, S, 2005, Effective C ++, третье издание. Пункт 4: убедитесь, что объекты инициализированы прежде чем они будут использованы. Аддисон Уэсли, Рединг, Массачусетс.
3. Страуструп, B, 2000, Специальный выпуск языка программирования C ++. Раздел 10.4.9, Эддисон Уэсли, Рединг, Массачусетс.

Answer 2

По предположению, CRT сообщает о ложном срабатывании - следующий код показывает, что совместно используемый указатель работает правильно, по крайней мере, с g ++

#include <iostream>
#include "boost/shared_ptr.hpp"
using namespace std;
using namespace boost;

struct R {
    R() {
        cerr << "ctor" << endl;
    }

    ~R() {
        cerr << "dtor" << endl;
    }
};

struct A {
    static shared_ptr<R> ptr;

    A() {
     ptr =  shared_ptr<R>(new R);
    }

};

shared_ptr<R> A::ptr;
static A a;

int main() {
}

Он печатает:

ctor
dtor

Answer 3

Скорее всего, утечка обнаружена до того, как глобальные объекты будут уничтожены, и у shared_ptr есть шанс освободить объект, поэтому вероятна утечка false .