#include "stdafx.h"
#include <ctime>
#include <map>
#include <vector>
#include <Windows.h>
#include <iostream>

void foo(std::map<int, std::vector<float>>& m)
{
  for (size_t i = 0; i < 10; ++i)
  {
    std::vector<float> v;
    for (size_t j = 0; j < 100; ++j)
    {
      v.push_back(GetTickCount() / static_cast<float>(j));
      Sleep(10);
    }
    m[i] = v;
  }
}

int _tmain(int argc, _TCHAR* argv[])
{
  std::map<int, std::vector<float>> m;

  _CrtDumpMemoryLeaks();
  for (size_t i = 0; i < 10; ++i)
  {
    std::vector<float> v;
    for (size_t j = 0; j < 100; ++j)
    {
      v.push_back(static_cast<float>(j) / GetTickCount());
      Sleep(10);
    }
    m[i] = v;
  }
  _CrtDumpMemoryLeaks();

  Sleep(1000);

  foo(m);
  _CrtDumpMemoryLeaks();

  return 0;
}

'map.exe' (Win32): Loaded 'C:\Users\Andreas\Documents\Entwicklung\map\Debug\map.exe'. Symbols loaded.
'map.exe' (Win32): Loaded 'C:\Windows\SysWOW64\ntdll.dll'. Symbols loaded.
'map.exe' (Win32): Loaded 'C:\Windows\SysWOW64\kernel32.dll'. Symbols loaded.
'map.exe' (Win32): Loaded 'C:\Windows\SysWOW64\KernelBase.dll'. Symbols loaded.
'map.exe' (Win32): Loaded 'C:\Windows\SysWOW64\msvcp120d.dll'. Symbols loaded.
'map.exe' (Win32): Loaded 'C:\Windows\SysWOW64\msvcr120d.dll'. Symbols loaded.
Detected memory leaks!
Dumping objects ->
{190} normal block at 0x0048D568, 8 bytes long.
 Data: <l /     > 6C FE 2F 00 00 00 00 00 
{189} normal block at 0x0048D508, 36 bytes long.
 Data: <  H   H   H     > 08 D5 48 00 08 D5 48 00 08 D5 48 00 01 01 CD CD 
Object dump complete.

[*] in der map schon, aber einen eventuellen Fehler in der Standardbibliothek wirst du wohl nicht beheben wollen

Das Originalprogramm ist sauber wenn nur der Code entsprechend den Zeilen 27 - 36 aufgerufen wird. Wird aber der Code von foo (das ist das Datenupdate) aufgerufen in dem vector jedesmal etwas länger wird. Bekomme ich am Ende Leak Dumps.

Das Originalprogramm ist sauber wenn nur der Code entsprechend den Zeilen 27 - 36 aufgerufen wird. Wird aber der Code von foo (das ist das Datenupdate) aufgerufen in dem vector jedesmal etwas länger wird. Bekomme ich am Ende Leak Dumps.

Das was Randomuser gesagt hat, gilt immer noch. Wenn du CrtDumpMemoryLeaks im gleichen Scope aufrufst, wo deine Objekte liegen, dann ist klar, dass du vermeintliche Leaks siehst, denn diese Objekte existieren schließlich noch.

Ansonsten klingt die Frage schwer danach, dass wir dir sagen sollen, was an dem Code, den du uns nicht gezeigt hast, falsch ist. Was unmöglich ist.

int _tmain(int argc, _TCHAR* argv[])
{
  {
    std::map<int, std::vector<float>> m;

    for (size_t i = 0; i < 10; ++i)
    {
      std::vector<float> v;
      for (size_t j = 0; j < 100; ++j)
      {
        v.push_back(static_cast<float>(j) / GetTickCount());
        Sleep(10);
      }
      m[i] = v;
    }

    Sleep(1000);

    foo(m);
  }
  _CrtDumpMemoryLeaks();

  return 0;
}

Dann muß ich mir am Montag meinen Code mal ansehen was ich sonst noch an Sauereien drin habe (wäre zu einfach gewesen )

Suchst du irgendeinen konkreten Fehler?

Suchst du irgendeinen konkreten Fehler?

Ja, leider.

Mein Programm lädt eine Datei und liest die Werte in die Map ein. Dann läuft ein Timer der regelmäßig prüft ob die Datei (ein Tracefile aus meinen Steuerprogrammen) geändert / ein neuer Datensatz hinzugefügt wurde. Wenn dem so ist, wird die gleiche Routine verwendet um die Map zu überschreiben / den Datensatz anzuhängen.

Wenn ich nun das Tracefile nur einfach einlese ist alles sauber, erst wenn der Timer eingeschaltet wird und die Funktion wiederholt aufgerufen wird bekomme ich nach der Debugsession Speicherdumps angezeigt.

Mehr zeigen kann ich aber erst nächste Woche, nachdem ich nochmal selbst Zeit in meinen Mist gesteckt habe .

Danke Euch für Eure Hinweise.

Ich hab das Problem gefunden. Das Problem ist, dass ich für das Update der Daten einen Timer einsetze. Als ordentlicher Mensch habe ich den Timer auch im Destructor der CMainFrame gekillt. Das ist jedoch grundverkehrt, weil zu diesem Zeitpunkt das Fenster garnicht mehr existiert. Der KillTimer gehört nach DestroyWindow und kommen auch keine Leaks mehr.

Damit sollte das Thema vieleicht eher nach MCF (Visual C++) verschoben werden.