[RISOLTO][C++] Problema con new e delete

[alukard990]

Salve a tutti da poco ho deciso di cominciare a programmare in C++ in ambiente linux. Premetto che ho una discreta esperienza nella programmazione ma fino a poco tempo fa lavoravo sotto win. Avendo fatto questo step ho pensato che era il caso di ricominciare dalle basi ed ecco che ho scritto questo semplicissimo codice che mi permette di visualizzare un intero inserito da tastiera. Non volendo ricominciare letteralmente da 0 ho pensato di ripartire direttamente dai puntatori e dall'allocazione dinamica delle strutture dati

Codice: Seleziona tutto

#include <iostream>

using namespace std;

int main()
{
 int *p=new int;
 int a;
 
 p=&a;
 cout<<"Inserire elemento: ";
 cin>>*p;
 cout<<"L'elemento inserito è: ";
 cout<<*p<<endl;
 delete p;
 return 0;
}

Questo è il relativo makefile

Codice: Seleziona tutto

all: start

start: main.o
	g++ -o start main.o
main.o: main.cpp
	g++ -c main.cpp
clean:
	rm -f *.o
	rm -f ./start
	rm -f *~

Questo è il relativo output

Codice: Seleziona tutto

Inserire elemento: 6
L'elemento inserito è: 6
*** Error in `./start': free(): invalid pointer: 0xbfb62598 ***
======= Backtrace: =========
/lib/i386-linux-gnu/libc.so.6(+0x767c2)[0xb752d7c2]
/lib/i386-linux-gnu/libc.so.6(+0x77510)[0xb752e510]
/usr/lib/i386-linux-gnu/libstdc++.so.6(_ZdlPv+0x1f)[0xb76d1a3f]
./start[0x80488fc]
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf5)[0xb74d0905]
./start[0x8048791]
======= Memory map: ========
08048000-08049000 r-xp 00000000 08:01 400427     /home/ciro/Scrivania/miei_es_SO/ripassi/elemento_din/start
08049000-0804a000 r--p 00000000 08:01 400427     /home/ciro/Scrivania/miei_es_SO/ripassi/elemento_din/start
0804a000-0804b000 rw-p 00001000 08:01 400427     /home/ciro/Scrivania/miei_es_SO/ripassi/elemento_din/start
08738000-08759000 rw-p 00000000 00:00 0          [heap]
b7472000-b7474000 rw-p 00000000 00:00 0 
b7474000-b74b5000 r-xp 00000000 08:01 1049587    /lib/i386-linux-gnu/libm-2.17.so
b74b5000-b74b6000 r--p 00040000 08:01 1049587    /lib/i386-linux-gnu/libm-2.17.so
b74b6000-b74b7000 rw-p 00041000 08:01 1049587    /lib/i386-linux-gnu/libm-2.17.so
b74b7000-b7665000 r-xp 00000000 08:01 1049534    /lib/i386-linux-gnu/libc-2.17.so
b7665000-b7667000 r--p 001ae000 08:01 1049534    /lib/i386-linux-gnu/libc-2.17.so
b7667000-b7668000 rw-p 001b0000 08:01 1049534    /lib/i386-linux-gnu/libc-2.17.so
b7668000-b766c000 rw-p 00000000 00:00 0 
b766c000-b7687000 r-xp 00000000 08:01 1054626    /lib/i386-linux-gnu/libgcc_s.so.1
b7687000-b7688000 r--p 0001a000 08:01 1054626    /lib/i386-linux-gnu/libgcc_s.so.1
b7688000-b7689000 rw-p 0001b000 08:01 1054626    /lib/i386-linux-gnu/libgcc_s.so.1
b7689000-b7766000 r-xp 00000000 08:01 923334     /usr/lib/i386-linux-gnu/libstdc++.so.6.0.18
b7766000-b776a000 r--p 000dc000 08:01 923334     /usr/lib/i386-linux-gnu/libstdc++.so.6.0.18
b776a000-b776b000 rw-p 000e0000 08:01 923334     /usr/lib/i386-linux-gnu/libstdc++.so.6.0.18
b776b000-b7772000 rw-p 00000000 00:00 0 
b7784000-b7789000 rw-p 00000000 00:00 0 
b7789000-b778a000 r-xp 00000000 00:00 0          [vdso]
b778a000-b77aa000 r-xp 00000000 08:01 1049510    /lib/i386-linux-gnu/ld-2.17.so
b77aa000-b77ab000 r--p 0001f000 08:01 1049510    /lib/i386-linux-gnu/ld-2.17.so
b77ab000-b77ac000 rw-p 00020000 08:01 1049510    /lib/i386-linux-gnu/ld-2.17.so
bfb44000-bfb65000 rw-p 00000000 00:00 0          [stack]
Annullato (core dump creato)

Come avete potuto vedere ho ottenuto l'output desiderato ma di seguito escono una serie di cose che non riesco a decifrare data la mia pochissima esperienza nell'ambito linux. Qualcuno sa spiegarmi il motivo? Il problema potrebbe essere relativo al fatto che sono su macchina virtuale? Ho provato a scrivere lo stesso codice sotto ambiente win giusto per capire se sbagliavo qualcosa, ma come pensavo non ho commesso errori (o credo).

[antex]

Impara sin d'ora a usare uno strumento come valgrind. Se compili con l'opzione -g (per aggiungere le informazioni di debug):

Codice: Seleziona tutto

g++ -g main.cpp -o start

ed esegui valgrind con le opportune opzioni, ecco cosa ti compare:

Codice: Seleziona tutto

$ valgrind --show-reachable=yes --leak-check=full --track-origins=yes ./start
==28208== Memcheck, a memory error detector
==28208== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
==28208== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==28208== Command: ./start
==28208== 
Inserire elemento: 3
L'elemento inserito è: 3
==28208== Invalid free() / delete / delete[] / realloc()
==28208==    at 0x4C2BADC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==28208==    by 0x400B34: main (main.cpp:15)
==28208==  Address 0x7fefffdd4 is on thread 1's stack
==28208== 
==28208== 
==28208== HEAP SUMMARY:
==28208==     in use at exit: 4 bytes in 1 blocks
==28208==   total heap usage: 1 allocs, 1 frees, 4 bytes allocated
==28208== 
==28208== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==28208==    at 0x4C2A879: operator new(unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==28208==    by 0x400ACE: main (main.cpp:7)
==28208== 
==28208== LEAK SUMMARY:
==28208==    definitely lost: 4 bytes in 1 blocks
==28208==    indirectly lost: 0 bytes in 0 blocks
==28208==      possibly lost: 0 bytes in 0 blocks
==28208==    still reachable: 0 bytes in 0 blocks
==28208==         suppressed: 0 bytes in 0 blocks
==28208== 
==28208== For counts of detected and suppressed errors, rerun with: -v
==28208== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 2 from 2)

Ti evidenzio le porzioni più importanti:

Codice: Seleziona tutto

==28208== Invalid free() / delete / delete[] / realloc()
==28208==    at 0x4C2BADC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==28208==    by 0x400B34: main (main.cpp:15)
==28208==  Address 0x7fefffdd4 is on thread 1's stack

Codice: Seleziona tutto

==28208== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==28208==    at 0x4C2A879: operator new(unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==28208==    by 0x400ACE: main (main.cpp:7)

Allora, qual è il problema?

[matteovid]

ciao

segui il consiglio di @antex

e poi leggi

Spoiler

Mostra

Operatore delete
In C++, l'operatore binario delete (con un operando opzionale e l'altro obbligatorio) dealloca la memoria dell'area heap puntata dall'operando (obbligatorio). Non restituisce alcun valore e quindi deve essere usato da solo in un'istruzione (non essendo né un l-value né un r-value non può essere usato in un'espressione con altre operazioni).

Es.:

Codice: Seleziona tutto

allocazione: int* punt = new int ;
deallocazione:  delete punt ;

Contrariamente all'apparenza l'operatore delete non cancella il puntatore né altera il suo contenuto: l'unico effetto é di liberare la memoria puntata rendendola disponibile per ulteriori allocazioni (se l'operando non punta a un'area heap alcuni compilatori generano un messaggio di errore (o di warning), altri no, ma in ogni caso l'operatore delete non ha effetto).

Se l'operando punta a un'area in cui è stato allocato un array di oggetti, bisogna inserire dopo delete l'operando opzionale, che consiste in una coppia di parentesi quadre (senza la dimensione dell'array, che il C++ é in grado di riconoscere automaticamente).
Es.:

Codice: Seleziona tutto

float* punt = new float [100] ; (alloca 100 oggetti float )
delete [ ] punt ; (libera tutta la memoria allocata)

L'operatore delete costituisce l'unico mezzo per deallocare memoria heap, che, altrimenti, sopravvive fino alla fine del programma, anche quando non é più raggiungibile.

Es.:

Codice: Seleziona tutto

int* punt = new int ; (alloca un oggetto int nell'area heap e inizializza punt con il suo indirizzo)
int a ; (definisce un oggetto int nell'area stack)
punt = &a ; (assegna a punt un indirizzo dell'area stack; l'oggetto int dell'area heap non é più raggiungibile)

mi sembra strano che lo stesso codice in Windows sia eseguibile, cosa usi come compiler sotto Windows?

[alukard990]

Eseguendo valgrind ecco quello che mi esce

Codice: Seleziona tutto

==4051== Invalid free() / delete / delete[] / realloc()
==4051==    at 0x402B098: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
==4051==    by 0x80488FB: main (in /home/.../Scrivania/miei_es_SO/ripassi/elemento_din/start)
==4051==  Address 0xbe8dffd8 is on thread 1's stack
==4051== 
==4051== 
==4051== HEAP SUMMARY:
==4051==     in use at exit: 4 bytes in 1 blocks
==4051==   total heap usage: 1 allocs, 1 frees, 4 bytes allocated
==4051== 
==4051== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==4051==    at 0x4029F34: operator new(unsigned int) (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
==4051==    by 0x8048881: main (in /home/.../Scrivania/miei_es_SO/ripassi/elemento_din/start)
==4051== 
==4051== LEAK SUMMARY:
==4051==    definitely lost: 4 bytes in 1 blocks
==4051==    indirectly lost: 0 bytes in 0 blocks
==4051==      possibly lost: 0 bytes in 0 blocks
==4051==    still reachable: 0 bytes in 0 blocks
==4051==         suppressed: 0 bytes in 0 blocks
==4051== 
==4051== For counts of detected and suppressed errors, rerun with: -v
==4051== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)

Per @matteovid, sotto win ho mingw

[alukard990]

Sinceramente non capisco l'errore, sotto win ho sempre fatto così e non mi ha mai dato problemi.

[antex]

Sinceramente non capisco l'errore

Te lo dice esplicitamente valgrind dove risiede l'errore:

• Invalid free() / delete / delete[] / realloc(): hai usato erroneamente uno di questi operatori;
• at 0x4C2BADC: operator delete(void*) (...): in particolare è una delete;
• by 0x400B34: main (main.cpp:15): che si trova nel file main.cpp a riga 15;
• Address 0x7fefffdd4 is on thread 1's stack: quell'indirizzo (è facile immaginare che si tratta dell'indirizzo a cui punta p e su cui fai delete) si trova sullo stack (del thread numero 1 del tuo processo).

sotto win ho sempre fatto così e non mi ha mai dato problemi.

Che non ti abbia mai dato problemi non significa che non fosse errato, un eventuale errore può emergere solo in contesti particolari o su alcune piattaforme e non su altre. Valgrind serve proprio a evitare casi come questo. Ti dice pure che hai un "memory leak" su un blocco di 4 byte (la dimensione di un int), dato che non liberi la zona di memoria che avevi allocato sullo heap.

[zeek]

Sinceramente non capisco l'errore, sotto win ho sempre fatto così e non mi ha mai dato problemi.

in pratica int* p = new int non serve, visto che poi scrivi p=&a, e visto che dopo p=&a p punta all'area stack e non alla heap non puoi chiamare delete.
(chiedo venia se ho detto castronerie, non ne so praticamente niente di c++ ma questo è quello che ho capito dal post di matteovid)

[alukard990]

Ho corretto il codice in questo modo

Codice: Seleziona tutto

#include <iostream>

using namespace std;

int main()
{
 int* p=new int;
 cout<<"Inserire elemento: ";
 cin>>*p;
 cout<<"L'elemento inserito è: ";
 cout<<*p<<endl;
 delete p;
 return 0;
}

Escono sempre le stesse problematiche che non ho deallocato i 4 byte sulla heap e che sbaglio ad usare l'operatore delete. Ho consulato un libro di programmazione e l'allocazione e la deallocazione mi suggerisce di farla proprio come ho sempre fatto

Codice: Seleziona tutto

int* p=new int;
delete p;

[matteovid]

ciao

il tuo ultimo esempio a me su Debian va bene ...

Spoiler

Mostra

#include <iostream>

using namespace std;

int main()
{
int *p=new int;
cout<<"Inserire elemento: ";
cin>>*p;
cout<<"L'elemento inserito è: ";
cout<<*p<<endl;
delete p;
return 0;
}

Codice: Seleziona tutto

$ g++ -g -o alucard alucard.cpp

Codice: Seleziona tutto

$ ./alucard 
Inserire elemento: 2
L'elemento inserito è: 2
$ 

Codice: Seleziona tutto

$ valgrind --show-reachable=yes --leak-check=full --track-origins=yes ./alucard
==6543== Memcheck, a memory error detector
==6543== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.
==6543== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info
==6543== Command: ./alucard
==6543== 
Inserire elemento: 45
L'elemento inserito è: 45
==6543== 
==6543== HEAP SUMMARY:
==6543==     in use at exit: 0 bytes in 0 blocks
==6543==   total heap usage: 1 allocs, 1 frees, 4 bytes allocated
==6543== 
==6543== All heap blocks were freed -- no leaks are possible
==6543== 
==6543== For counts of detected and suppressed errors, rerun with: -v
==6543== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
$ 

compilo con g++ versione

Codice: Seleziona tutto

$ g++ --version
g++ (4.7.2-2) 
Copyright (C) 2012 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 $

[alukard990]

Ho provato a compilare senza l'uso del makefile e il codice è corretto, viene allocata e deallocata memoria correttamente. Se uso il makefile invece noto che mi crea 2 file "eseguibili" (non so come si definiscono su linux visto che i .exe non esistono, mi scuso per la mia "nabbagine") che sono a.out(che non capisco da dove esce) ed "eseguibile" che appunto ho chiamato così nel makefile. Se richiamo da terminale a.out va tutto liscio, se richiamo eseguibile escono i soliti errori. Potresti vedere se vi è qualche problema nel makefile?

Codice: Seleziona tutto

 

all: start

start: main.o
	g++ -o eseguibile main.o
main.o: main.cpp
	g++ -g main.cpp
clean:
	rm -f *.o
	rm -f ./eseguibile
	rm -f *~

[antex]

Sbagli in come chiami g++. Con il comando

Codice: Seleziona tutto

g++ -o eseguibile main.o

dici a g++ di creare un file eseguibile di nome eseguibile partendo dal codice oggetto main.o (linking).

Però, col comando

Codice: Seleziona tutto

g++ -g main.cpp

dici a g++ di compilare il file main.cpp (con le informazioni di debug), eseguirne il linking e produrre un file eseguibile con un nome a suo piacimento (di default è a.out). Quindi main.o non viene affatto creato (se esiste è un file vecchio, che viene usato per sbaglio).

Per correggere devi sostituire il secondo comando con qualcosa come:

Codice: Seleziona tutto

g++ -g -c main.cpp -o main.o

Leggiti le opzioni supportate da g++ (g++ --help), in particolare quella -c.

[alukard990]

Ho corretto il makefile in questo modo, credo che stavolta sia andato tutto per il verso giusto. Spero non sia un caso

Codice: Seleziona tutto

all: start

start: main.o
	g++ -o eseguibile main.o
main.o: main.cpp
	g++ -g -c main.cpp
clean:
	rm -f *.o
	rm -f ./eseguibile
	rm -f *~

Per sicurezza dalla cartella interessata ho cancellato il vecchio file main.o per vedere se veniva creato, ed effettivamente è stato creato.

[matteovid]

Ciao Alukard

complimenti

se pensi che hai risolto metti nel titolo del primo post

Codice: Seleziona tutto

[RISOLTO][C++] Problema con new delete

[alukard990]

Si tranquillo aspettavo solo una conferma che davvero non sia un caso

[alukard990]

Per una correttezza al 100% bisogna far puntare il puntatore ad un indirizzo nullo all'atto dell'allocazione e deallocazione in memoria. Se non facessi ciò avrei il cosidetto problema del "dangling reference" (se non lo conoscete basta fare una ricerca che troverete tutte le info che vi servono). Posto il codice definitivo per coloro che sono alle prime armi col C++.

Codice: Seleziona tutto

#include <iostream>

using namespace std;

int main()
{
 int* p;
p=NULL;
p=new int;
 cout<<"Inserire elemento: ";
 cin>>*p;
 cout<<"L'elemento inserito è: ";
 cout<<*p<<endl;
 p=NULL;
 delete p;
 return 0;
}

[antex]

Per una correttezza al 100% bisogna far puntare il puntatore ad un indirizzo nullo all'atto dell'allocazione e deallocazione in memoria. Se non facessi ciò avrei il cosidetto problema del "dangling reference" (se non lo conoscete basta fare una ricerca che troverete tutte le info che vi servono). Posto il codice definitivo per coloro che sono alle prime armi col C++.

Codice: Seleziona tutto

#include <iostream>

using namespace std;

int main()
{
 int* p;
p=NULL;
p=new int;
 cout<<"Inserire elemento: ";
 cin>>*p;
 cout<<"L'elemento inserito è: ";
 cout<<*p<<endl;
 p=NULL;
 delete p;
 return 0;
}

Niente affatto:

Codice: Seleziona tutto

==10483== HEAP SUMMARY:
==10483==     in use at exit: 4 bytes in 1 blocks
==10483==   total heap usage: 1 allocs, 0 frees, 4 bytes allocated
==10483== 
==10483== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==10483==    at 0x4C2A879: operator new(unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==10483==    by 0x4009D6: main (in /var/tmp/example)
==10483== 
==10483== LEAK SUMMARY:
==10483==    definitely lost: 4 bytes in 1 blocks
...

Il primo

Codice: Seleziona tutto

p=NULL;
p=new int;

non serve a niente: di più assegnamenti in fila solo l'ultimo ha senso (gli altri potrebbero pure essere elisi dal compilatore).

Il secondo

Codice: Seleziona tutto

 p=NULL;
 delete p;

è dannoso: in questo modo rendi vana la delete, perché sostanzialmente fai una delete NULL che non sortisce alcun effetto. Quale memoria dovrebbe venire liberata?

Semmai la cosa utile sarebbe:

Codice: Seleziona tutto

delete p;
p = NULL;

perché in questo modo, se accidentalmente fai di nuovo

Codice: Seleziona tutto

delete p; // p == NULL

non succede niente di male.

Il mio consiglio è sempre quello: valgrind. Sia qui che lì.