ich hab ein kleines Problem.
Ich muss im Rahmen eines Teamprojects betreiben.
Momentan bin ich dabei die Memoryleaks im Programmcode zu beseitigen.
Zu sagen ist das ich einfach nur den Code bekommen habe, programmiert habe ich davon nix.
Jetzt bekomme ich aber einfach einige Memoryleaks nicht beseitigt, weil ich nicht weiß wie ich den mit malloc reservierten Speicher wieder freigeben kann. Besser gesagt "wo und wie" ich wieder freigeben kann.

Der Memoryleak verweißt mich auf folgende Allokierung in einer .cpp.

void c_emxInit_real_T(emxArray_real_T **pEmxArray, int32_T b_numDimensions)
{
  emxArray_real_T *emxArray;
  int32_T loop_ub;
  int32_T i;
  *pEmxArray = (emxArray_real_T *)malloc(sizeof(emxArray_real_T));
  emxArray = *pEmxArray;
  emxArray->data = (real_T *)NULL;
  emxArray->numDimensions = b_numDimensions;

  //verursacht Memory leak

emxArray->size = (int32_T *)malloc((uint32_T)(sizeof(int32_T) * b_numDimensions));

  emxArray->allocatedSize = 0;
  emxArray->canFreeData = TRUE;
  loop_ub = b_numDimensions - 1;
  for (i = 0; i <= loop_ub; i++) {
    emxArray->size[i] = 0;
  }

}

Aufgerufen wird die oben stehende Funktion in einer anderen .cpp hier..

emxArray_real_T *emxCreateND_real_T(int32_T b_numDimensions, int32_T *b_size)
{
  emxArray_real_T *emx;
  int32_T numEl;
  int32_T loop_ub;
  int32_T i;
c_emxInit_real_T(&emx, b_numDimensions);
  numEl = 1;
  loop_ub = b_numDimensions - 1;
  for (i = 0; i <= loop_ub; i++) {
    numEl *= b_size[i];
    emx->size[i] = b_size[i];
  }

  emx->data = (real_T *)calloc((uint32_T)numEl, sizeof(real_T));
  emx->numDimensions = b_numDimensions;
  emx->allocatedSize = numEl;
  return emx;
}
}

mit dieser Funktion wird in der Klassen-cpp folgende Variable deklariert.

syncSequenceT2 = emxCreateND_real_T(1, size);

Mir ist klar, dass das mir da jetzt eher schwer zu helfen ist. Vor allem ohne den kompletten Code.
Aber es wäre schon sehr hilfreich allein zu wissen wie genau den der oben makierte malloc befehl genau aufgegaut ist. Ich hab einfach keinen Überblick bei all den pointern und pfeiloperatoren.

Also wo in den drei Files muss ich wieder freigeben und was erwartet free dabei von mir.
Vielen dank schonmal

Gruß Schorsch

Denn malloc/free ist die Variante aus C.

In C++ sollte man, wenn man da keine andere bessere Lösung findet, new/delete bevorzugen.

So weit ein wenig Theorie.

Das in der Praxis in einem grossen Projekt zu bearbeiten, kann da umfangreicher werden.

Hab das nicht gründlich gelesen. Hier sollten auch noch ein paar Infos drin stehen:
http://www.codeproject.com/Articles/10141/RAII-Dynamic-Objects-and-Factories-in-C ++

Also wo in den drei Files muss ich wieder freigeben

Da, wo du das Zeug nicht mehr benötigst. Wenn syncSequenceT2 ein Klassenmember ist, vermutlich im Destruktor der Klasse.

Schorsch schrieb:

und was erwartet free dabei von mir.

Die Zeiger, die von malloc und calloc geliefert wurden.

Deine Funktion c_emxInit_real_T() allokiert Speicher, und du darfst nun darüber räseln, wer eigentlich dafür verantwortlich ist diesen wieder freizugeben.

Du könnest probeweise mal hingehen und emxArray_real_T als Klasse implementieren, alle Zugriffe knallhart mittels Get() und Set() kapseln, jewede Allokation/Freigabe auf emxArray_real_T mittels new/delete machen und die interne Allokation von Membern im Konstruktor/Destrukor erledigen.

Aber das sieht nach einer dicken fetten Arbeitsbeschaffungsmaßnahme aus.