Newsgroup: it.comp.os.linux.development
Titolo: Problemi con l'allocazione di memoria

Ho scritto un programmino che legge delle frame (video) da un file di
ingresso le processa in un certo modo trascrivendole su di una classe
(bitstring) creata da me e poi spedisce il risultato su una socket.
La classe non è altro che una stringa alla quale ho aggiunto la 
possibilità di scrivere anche un singolo bit:
class bitstring {
    unsigned char   byte_buffer;
    int             num_bit;
    int             num_byte;
    int  	    bit_offset;
  public:
    int DIM;
    unsigned char * stringa;
    bitstring(int);
    ~bitstring();
    ....
};
Questi sono costruttore e distruttore
bitstring:: bitstring (int dim)
{
 stringa = new (unsigned char[dim]);
 nyte_buffer=0;
 num_bit=0;
 num_byte=0;
 bit_offset=0;
 DIM=dim;
}
bitstring::~bitstring ()
{
  delete [] stringa;
}
Finita la lunga premessa arrivo al punto, il programma di cui parlavo
sopra chiama ripetutatemente una funzione la cui struttura è la
seguente:
void estrai (int dim,...)
{
 bitstring out_string(dim)   //dim può assumere i valori 360 e 1440
 ...
}
per quanto ne so all'uscita di questa funzione l'oggetto out_string
dovrebbe essere eliminato con il distruttore, però accade che dopo un
paio di volte che la funzione è stata chiamata il programma riceve un
SIGABORT,e per la precisione ho potuto constatare (con DDD) che questo
avviene nella prima riga del costruttore (quella con il new) e questo
mi ha fatto pensare ai problemi di memoria. Infatti tralaltro questo
errore lo ricevo solo sul computer di casa (64M di ram) e non con 
quello del lavoro (256M di ram) dove il programma gira correttamente.
Dove sbaglio ? cosa posso fare per risolvere il problema?
-- 
  _  _ >>Now on Linux<<  _     || ICQ number.................Non lo uso
 | \| |___ _____ ___ ___|_|___ || Home-Page ................Non ce l'ho
 | .` | -_|     | -_|_ -| |_ -||| E-Mail................Non l'avrai mai
 |_|\_|___|_|_|_|___|___|_|___||| Un Nemesis che ha pochi e-contatti ;)


quando crei una classe i cui membri sono puntatori ad aree di memoria, e
non semplici "tipi" di base (e non), e` necessario fornirla, oltre che
del costruttore e del distruttore, anche di:
1) costruttore di copia, del tipo 
bitstring(const bitstring &b )
{
	stringa = new (unsigned char)[b.DIM];
	DIM = b.DIM;
	// etc. etc.
}
2) operatore di copia
const bitstring &operator = (const bitstream &b )
{
	if (this != &b)
	{
	// qua in pratica metti prima il distruttore per eliminare
	// l'oggetto corrente e poi il costruttore di copia
	// per copiare il parametro
	}
	return *this;
}
inoltre devi fornire la classe che hai scritto di un costruttore di
default, che allochi comunque qualcosa... da fare deallocare al
distruttore...
altrimenti il delete cerchera` di deallocare un puntatore inizializzato
a casaccio.
questo puoi farlo semplicemente modificando il prototipo del costruttore
che hai messo in:
bitstring(int=0);
con questi accorgimenti, la tua classe sara` a prova di bomba.
ciao!
andrea

con questi accorgimenti, la tua classe sara` a prova di bomba.
Ti ringrazio per i suggerimenti, in effetti il costruttore di copia l'ho
gia implementato, le altre cose ancora no.
Ah cmq il problema l'ho risolto, era una banalissima scrittura out-bound
su una stringa ;)


 possibilità di scrivere anche un singolo bit:
invece di avere dei mal di testa su una tua classe creata ex-novo, 
perche' non usi std::vector<bool>, che fa proprio cio' che ti serve, 
gestisce la memoria per conto suo ed e' ottimizzata?

 gestisce la memoria per conto suo ed e' ottimizzata?
esiste anche std::bitset
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

noname ha scritto : 

Ho gia risposto a questa domanda [cit.] ;)
A parte gli scherzi, se non ho capito male vector<bool> crea un vettore
di bool, ma un bool è cmq rappresentato da un *byte*, invece io avevo
bisogno di poter scrivere o leggere su una stringa un *bit*, e perciò
ho implementato quella classe. Più che altro avrei potuto usare al posto
del _unsigned char *_ una bella _string_, però purtroppo quando ho 
scritto questa classe avevo ripreso da poco il C++ e non sapevo che 
esistesse (ho imparato il C++ con il Borland C++ 3.0, e a quei tempi 
std::string non esisteva ancora).


 bisogno di poter scrivere o leggere su una stringa un *bit*, 
std::vector<bool> e' garantito essere ottimizzato per rappresentare ogni 
valore con un bit anziche' un byte (e cmq non e' affatto detto che 
sizeof(bool)==1; per questioni di prestazioni potrebbe anche essere uguale 
a sizeof(int)). Cmq esiste anche std::bitset che fa proprio al caso tuo.
