[c++] problema new delete e vector

[mogre]

allora, ho del codice preesistente che suppongo crei dei memory leak, volevo dargli una sistemata ma ho trovato qualche problema, questo è il codice:

[...]

				unsigned shape_count = 0;
				vector<double*> pvec, svec, cvec, fmvec, fsdvvec;
				vector<double> avec;

				//for all points of contour
				for (; cont; cont = cont->h_next)
		  		{
[...]
					{
[...]
						double *feature = new double[3];
						double *color = new double[3];
						double *position = new double[2];

						compute_shape_feature(points, shape_num_point, shape_per, shape_area, feature, position, newFeatures, subImageMargin, startP, endP);
						compute_color_feature(imgN, position, color);


[...]

//QUESTO L'HO MESSO IO, E' CORRETTO COME ALLOCO IL VETTORE E COME LIBERO LA MEMORIA?
				  		GlcmMatrix *directionalGLCM[4];
				  		directionalGLCM[0] = new GlcmMatrix(GlcmLevel, WindowSize, 1, 0);
				  		directionalGLCM[1] = new GlcmMatrix(GlcmLevel, WindowSize, 1, -1);
				  		directionalGLCM[2] = new GlcmMatrix(GlcmLevel, WindowSize, 0, 1);
				  		directionalGLCM[3] = new GlcmMatrix(GlcmLevel, WindowSize, 1, 1);
[...]

				  		//free the memory
						for (int k = 0; k < 4; k++)
						{
							delete directionalGLCM[k];
						}



						#ifdef DEBUG
						cout << endl << "Shape " << shape_count << "------------------" << endl;
						cout << "Contour's points: " << shape_num_point << endl;
						cout << "Perimeter: " << shape_per << endl;
						cout << "Area: " << shape_area << endl;
						cout << "Feature: " << feature[0]  << " " << feature[1] << " " << feature[2] << endl;
						cout << "Color: " << color[0]  << " " << color[1] << " " << color[2] << endl;
						cout << "Center Position: " << position[0] << " " << position[1] << endl;
						#else
						cout << ".";
						pvec.push_back(position);
						cvec.push_back(color);
						svec.push_back(feature);
						avec.push_back(shape_area);
						#endif

						//[red]memory leak!!! SE LO DECOMMENTO MEMORIZZA NEL FILE SOLO L'ULTIMO INSIEME DI VALORI RIPETUTO TANTE VOLTE QUANTE ESEGUE IL CICLO[/red]
						//delete [] feature;
						//delete [] color;
						//delete [] position;

					}
		  		}
[...]

				cout << "ok" << endl;

				vector<double*>::iterator its = svec.begin(), itc = cvec.begin(), itp = pvec.begin();
			    vector<double>::iterator ita = avec.begin();

			    //append to file
			    fprintf(pFile, "%s\n", fname.str().c_str());
		    	fprintf(pFile, "%d\n", shape_count);

			    while(its != svec.end())
			    {
			    	fprintf(pFile,"%f\n", *ita);
			    	fprintf(pFile, "%f %f\n", (*itp)[0], (*itp)[1]);
			    	fprintf(pFile, "%f %f %f\n", (*its)[0], (*its)[1], (*its)[2]);
			    	fprintf(pFile, "%f %f %f\n", (*itc)[0], (*itc)[1], (*itc)[2]);
			    	its++; itc++; itp++; ita++;
			    }

come ho scritto anche nel codice, se provo a fare il delete, tutti i gruppi di valori del file sono uguali, se lascio tutto commentato invece funziona tutto bene (anche se credo crei memory leak, in quanto ogni cosa con new poi ha bisogno del delete...).
Ho provato anche a dichiarare questi:

						double *feature = new double[3];
						double *color = new double[3];
						double *position = new double[2];

come semplici vettori, togliendo quindi i new e i delete:

						double feature[3];
						double color[3];
						double position[2];

ma il problema non cambia.

Ho anche provato a spostare fuori da ciclo sia le dichiarazioni delle variabili (prima dell'ingresso del ciclo) e il loro delete (dopo la fine del ciclo), ma il risultato non cambia.
E' corretto lasciar le cose così?

[mogre]

up

[KrOW]

Ciao ... Si, così com' è quel codice provoca dei memory leaks. Comunque, siccome memorizzi gli indirizzi di ogni array nei vector, basterebbe deallocare le aree di memoria precedentemente allocate attraverso gli stessi vector dopo il while (ammesso che dopo quest' ultimo non servino più). Es:

while( its != svec.end() )
{
...
}

for( ita=avec.begin(); ita!=avec.end(); ++ita )
   delete[] *ita;
avec.clear();

for( its=svec.begin(); its!=svec.end(); ++its )
   delete[] *its;
svec.clear();

for( itc=ivec.begin(); itc!=ivec.end(); ++itc )
   delete[] *itc;
ivec.clear();

for( itp=pvec.begin(); itp!=pvec.end(); ++itp )
   delete[] *itp;
pvec.clear();

Va da se che devi inserire i vari double* nei vettori anche se si è in modalità debug (quindi dovresti eliminare quella compilazione condizionale) ...
P.S: Non "uppare" così presto i tuoi post. Sai che casino se farebbero tutti così???

[mogre]

perfetto grazie, adesso provo! Anche se pensandoci però, il programma finisce praticamente con la scrittura di quel file, quindi SE alla chiusura del programma, tutta la memoria che ha richiesto viene deallocata automaticamente (avviene?) il problema non si pone in quanto il programma termina.

è corretta questa parte di codice invece? E' tutto allocato e deallocato nella maniera corretta vero?

				  		GlcmMatrix *directionalGLCM[4];
				  		directionalGLCM[0] = new GlcmMatrix(GlcmLevel, WindowSize, 1, 0);
				  		directionalGLCM[1] = new GlcmMatrix(GlcmLevel, WindowSize, 1, -1);
				  		directionalGLCM[2] = new GlcmMatrix(GlcmLevel, WindowSize, 0, 1);
				  		directionalGLCM[3] = new GlcmMatrix(GlcmLevel, WindowSize, 1, 1);
[...]

				  		//free the memory
						for (int k = 0; k < 4; k++)
						{
							delete directionalGLCM[k];
						}

Un altro consiglio, mi conviene spostare all'interno del for la scrittura del file in modo da avere cicli in meno?
Io suppongo di si.


ps: scusate per il troppo tempestivo up.

[MItaly]

Originariamente inviato da mogre
perfetto grazie, adesso provo! Anche se pensandoci però, il programma finisce praticamente con la scrittura di quel file, quindi SE alla chiusura del programma, tutta la memoria che ha richiesto viene deallocata automaticamente (avviene?) il problema non si pone in quanto il programma termina.

La memoria sui sistemi operativi moderni viene deallocata automaticamente al momento della terminazione del processo, ma è buona norma deallocare sempre la memoria allocata. Se un domani decidessi di cambiare la struttura del programma in modo che dopo la scrittura dei file avvenga qualcos'altro ti ricorderesti di aggiungere la parte di deallocazione? Inoltre l'uso di puntatori nei container STL è reso molto più agevole dagli smart pointers (che deallocano automaticamente la memoria a cui puntano nel momento in cui sono distrutti): dacci un'occhiata.