[C++] Errore di violazione memoria nel distruttore con template parametrico

[drudox]

Salve a tutti .. sto esercitandomi su template .. classi etc ..

provando a fare un semplice caso di template di classe con tipo paramentrico e tipo non paramentrico riscontro un errore che da debug risulta essere nell'distruttore

il codice e` il seguente

 

#include<iostream>
#include<iomanip>
#include<cstdlib>


using namespace std;



template< typename T , int N >

class Array{

public:
		Array( float = 0.0 );
		~Array();
		void initialize( float );
//		void setArray(N);

private:
		T* arrayPtr ;
		int size ;

};

template<typename T, int N>
Array<T,N>::Array( float value)
	: size( N > 0 ? N : 1 ),
      arrayPtr( new T[size] )
{
		initialize( value );	
}

template<typename T, int N>
Array<T,N>::~Array()
{
	delete[] arrayPtr;

}


template<typename T, int N>
void Array<T,N>::initialize( float v )
{

	for(int i=0 ; i < size ; i++) arrayPtr[i] = v ;

}



int main(){

		Array<float , 100 > A(0.2) ;
		system("echo 'pause'");


return 0 ;
}

[oregon]

Originariamente inviato da drudox
nell'distruttore

nel distruttore ...

Però, il codice e` illeggibile ...

EDIT: adesso hai corretto ... leggo ...

[drudox]

si mi sono accorto dopo aver postato e` ho gia` modificato .. scusa

[drudox]

preciso che se inizializzo

   : arrayPtr( new T[size] )

all interno del corpo del costruttore (ovviamente con :

    arrayPtr = new T[size]

)
il problema non sussiste

[oregon]

Il problema è nel costruttore ... nella lista di inizializzazione

: size( N > 0 ? N : 1 ),
arrayPtr( new T[size] )

il valore della size usato per la new non è quello assegnato con la prima parte ma il valore casuale precedente ...

[drudox]

come mai scusa ?

ho anche provato a verificare e la dimensione di size nel costruttore risulta esser esatta ... perche` viene usato un altro valore ?

[drudox]

si cmq se ripeto l'espressione all'interno delle quadre .. il problema non sussiste .. ma non me lo spiego

[shodan]

La constructor list viene valutata non come appare nel costruttore, ma in base all'ordine delle variabili nella classe.
In altre parole:

private:
		T* arrayPtr ;
		int size ;

prima viene inizializzato arrayPtr, dopo viene inizializzata size.

[drudox]

ess evvero .. dimenticavo .. Grazie infinite !!!