Problema con Heap

[felmoltor]

Hola a todos.

Tengo un problemilla de fuga de memoria en mi programa, el problema es que no se solucionarlo.
Basicamente tengo creada una clase que representa un pixel tal como esta:

Código:

class RGBLPixel
{
public:
[...]
private:
	unsigned char m_r;
	unsigned char m_g;
	unsigned char m_b;
};

y otra clase que modela un grupo de pixels tal como esta:

Código:

class PixelGroup
{
public:
[...]
private:
	int m_numPixels;
	RGBLPixel * m_grupo;
	[...]
};

que como veis tiene un vector de pixels.
Mi problema es en el destructor de la clase PixelGroup, en el que hago:

Código:

delete [] m_grupo;
m_numPixels=0;

Cuando creo una instancia de un grupo de pixels y le toca actuar al destructor (como por ejemplo al terminar un bucle en donde he definido un PixelGroup) me da un fallo de segmentación que no comprendo el por qué.
Si en el destructor comento la línea en donde hago el delete me deja de dar fallo y el programa sigue. El problema es que creo que así se me está produciendo fugas de memoria que no se como evitar.

Muchas gracias por vuestra ayuda

[Eternal Idol]

No mostras como reservas la memoria con lo cual es dificil adivinar, trata de reducir el codigo a la minima expresion (compilable).

[felmoltor]

La verdad es que es algo más complicado de lo que he puesto ahí.
Guardo más campos y estan relacionados en su creación unos con otros.

Intentaré resumir el código:

RGBPixel.h:

Código:

#include <iostream>

using namespace std;

class RGBLPixel
{
     public:
	  RGBLPixel();
	  RGBLPixel(unsigned char _red,unsigned char _green,unsigned char _blue);
	  virtual ~RGBLPixel();
     private:
	  unsigned char m_r;
	  unsigned char m_g;
	  unsigned char m_b;
};

RGBPixel.cpp:

Código:

#include "RGBPixel.h"

RGBLPixel::RGBLPixel()
{
    m_r = 0;
    m_g = 0;
    m_b = 0;
}

RGBLPixel::RGBLPixel(unsigned char _red,unsigned char _green,unsigned char _blue)
{
     	m_r = _red;
	m_g = _green;
	m_b = _blue;
}

RGBLPixel::~RGBLPixel()
{
         m_r = 0;
	 m_g = 0;
	 m_b = 0;
}

PixelGroup.h:

Código:

#include "RGBPixel.h"

class PixelGroup
{
     public:
	  PixelGroup();
	  void setNumClusters(int _nClusters);
	  void setNumPixels(int _n);
	  virtual ~PixelGroup();
     private:
	  int m_numPixels;
	  RGBLPixel * m_grupo;
	  int m_numClusters;
	  float ** m_pertenencias;
};

PixelGroup.cpp:

Código:

#include "PixelGroup.h"

PixelGroup::PixelGroup()
{
	m_numPixels = 0;
	m_numClusters = 0;
	m_grupo = NULL;
	m_pertenencias = NULL;
}

/*******************************************************************/

void PixelGroup::setNumClusters(int _nClusters)
{
	if (m_pertenencias != NULL)
	{
		for (int i=0;i<m_numClusters;i++)
			delete [] m_pertenencias[i];
		delete [] m_pertenencias;
		m_pertenencias = NULL;
	}		
	if (m_numPixels >0)
	{
		m_numClusters = _nClusters;
		m_pertenencias = new float * [m_numClusters];
		for (int i=0;i<m_numClusters;i++)
		{
			m_pertenencias[i] = new float [m_numPixels];
			memset(m_pertenencias[i],0,sizeof(float)*m_numPixels);
		}
	}
	else
	{
		m_numClusters = _nClusters;
	}
}

/*******************************************************************/

void PixelGroup::setNumPixels(int _n)
{
	if (m_grupo != NULL)
		delete [] m_grupo;
	m_numPixels = _n;
	m_grupo = new RGBLPixel [m_numPixels];
	memset(m_grupo,0,m_numPixels*sizeof(RGBLPixel));
	//si todavía no hemos creado la matriz de subpertenencias
	if (m_pertenencias == NULL && m_numClusters > 0)
	{
		m_pertenencias = new float * [m_numClusters];
		for (int i=0;i<m_numClusters;i++)
		{
			m_pertenencias[i] = new float [m_numPixels];
			memset(m_pertenencias[i],0,sizeof(float)*m_numPixels);
		}
	}
	
}

/*******************************************************************/

PixelGroup::~PixelGroup()
{
	if (m_pertenencias != NULL)
	{
		for (int i=0;i<m_numClusters;i++)
		{
			delete [] m_pertenencias[i];
		}
		delete [] m_pertenencias;
		m_pertenencias = NULL;
	}
	if (m_grupo != NULL)
	{
		delete [] m_grupo;
		m_grupo = NULL;
	}
	m_numClusters = 0;
	m_numPixels = 0;
}

prueba.cpp:

Código:

#include "PixelGroup.h"

using namespace std;

int main()
{
	PixelGroup pg;
	pg.setNumClusters(3);
	pg.setNumPixels(10);
	
	cout<<"Ahora va a haber un fallo de segmentacion"<<endl;
}

Ejecuta:

Código:

g++ -c RGBPixel.cpp
g++ -c PixelGroup.cpp
g++ -o prueba prueba.cpp RGBPixel.o PixelGroup.o

El vector m_pertenencias y m_grupo estan relacionados entre sí y compruebo que qué numero se ha especificado antes para crear los vectores de acuerdo al orden en que se han llamado a las funciones setNumPixels y setNumClusters.
En el destructor compruebo que sean diferentes de nulos para hacer los deletes en consecuencia. Este programa solo funciona cuando comento todos los deletes.

Muchas gracias por la ayuda.

[Eternal Idol]

El problema esta en esta linea:
memset(m_grupo,0,m_numPixels*sizeof(RGBLPixel));

No se para que haces esto, no sirve de nada ya que para inicializar los campos esta el constructor (donde lo haces). Lo unico que conseguis es sobreescribir el puntero al destructor "interno" (vector deleting destructor en este caso) que hay al principio de cada objeto.

[felmoltor]

Uff, que vergüenza...
Llevas razón. Estaría programando de carrerílla. Jeje.
Gracias

[Eternal Idol]

De nadas (solo lo depure y vi eso, en VC++ primero por cierto).