Newsgroup: it.comp.lang.c++
Titolo: Domanda su operatore new

mettiamo che io creo un codice del tipo
fate finta che le parentesi quadre siano graffe, sto cazzo di pan non mi
lascia scrivere le graffe con ctrl + alt + shift + č
int main()
[
 int *p = new int;
 int ciccio;
 cin >> ciccio;
 if (!ciccio)
  return 1;
 delete p;
 return 0;
]
qui c'č un possibile memory leak o no? La memoria allocata da new viene
distrutta dal SO quando il programma esce? Posso evitare di cancellare
qualcosa se esco subito dal programma?


ovviamente al termine del programma viene deallocata la memoria usata 
dal programma stesso, sia lo heap che le variabili statiche.

 La memoria allocata da new viene distrutta dal SO quando il programma esce? 
se intendi "viene chiamato il dtor", no.
se intendi viene deallocata la memoria, dipende dal SO.
// a.hpp
#ifndef A_HPP_INCLUDED
#define A_HPP_INCLUDED
#include <iostream>
struct A
{
   A(){ std::cout << "A::A() called"  << std::endl; }
  ~A(){ std::cout << "A::~A() called" << std::endl; }
};
#endif
//main1.cpp
int main()
{
  A* anA = new A;
}
//g++ -o main1 main1.cpp && ./main1
//A::A() called
//main2.cpp
#include "a.hpp"
#include <memory>
int main()
{
  std::auto_ptr<A> anA(new A);
}
//g++ -o main2 main2.cpp && ./main2
//A::A() called
//A::~A() called
-- 
sbirish.

 dal programma stesso, sia lo heap che le variabili statiche.
Anche se, aggiungo io, sarebbe sembra buona norma di programmazione 
liberare la memoria occupata prima di uscire :)
-- 
/**
  * Mattia Belletti - Undergraduate student @ 
cs.unibo.it
  * ICQ: 33292311   - email: 
mbel...@cs.unibo.it
  * IRC: BluShine   - site(s): 
http://cs.unibo.it/~mbellett
  * Linux registered user 299762 @ Linux registered machine 213003
  */

 liberare la memoria occupata prima di uscire :)
Si, anche perche' non tutti i O.S. sono "avanzati" come linux o windows,
alcuni sistemi operativi potrebbero non fare cio', specialmente quelli non
multi-tasking.
E' inoltre sbagliato perche' se uno lavora ad esempio su windows, e non usa
delete perche' sa che ci pensa l'O.S., beh, potrebbe prendere una cattiva
abitudine ed omettere delete anche quando necessario, come ad empio quando
si programma un programma che sta sempre attivo, ad esempio un
web-server.... Se ad ogni client che si connette noi usiamo un new (ad
esempio....) e poi ci dimentichiamo il delete, beh, dopo parecchi clients
questo potrebbe essere un problema!
Quindi, come dice Mattia e' una "buona norma di programmazione" liberare la
memoria allocata anche se subito prima di uscire, questo per vari motivi.
Tommy

 liberare la memoria occupata prima di uscire :)
Veramente lo fa già...
c'è un bel "delete p" a fine programma.
Infatti io non vedo rischi di memory leak
qui, visto che tutto quello che alloca viene
poi *sicuramente* deallocato prima di terminare.
A meno che il prog stesso venga terminato
brutalmente dall'esterno, ma anche così la
memoria sarebbe recuperata, visto che l'intero
*p è stato creato sull'heap...
Boh, per me sto programmino non può dare in
nessun caso dei memory leak...

poi *sicuramente* deallocato prima di terminare.
in caso di !ciccio, prima di returnare 1, non viene fatto il delete di
p
-- 
]\/[ad]\/[age (
www.mindreamz.net
)
"Un Maestro insegue semplicemente la sua visione di Eccellenza in
qualunque cosa sta facendo e lascia agli altri decidere se sta 
lavorando o giocando. A lui sembra sempre di fare entrambe." - Anonimo

 *p è stato creato sull'heap...
Sui sistemi operativi piu' comuni questo e' vero; non sono sicuro che
lo sia sempre.
Ciao,
Nicola

 lo sia sempre.
non lo è sempre, basta dire che non te lo garantisce il linguaggio,
e ci sono sistemi operativi che non te lo garantiscono
<cite>
 MY experience that I related was on IBM's MVS
 running TSO, where programs were loaded as subtasks (sub processes) not
 tasks. Additionally the malloc(3) function was layered directly on the 
 the system call, getmain, and conversely, free(3) on freemain. As a
 result, as a program exited, any unfreed memory was lost until you
 logged out of TSO. I can't relate how many hours I spent trying to
 locate all the memory leaks in the code because some junior coders were
 careless.
</cite>
il problema non trascurabile che cmq imho non è saltato fuori, è che se
non fosse un int* quello, ma una classe con un dtor non banale,
il sistema operativo può si liberarti la memoria(forse), 
ma non viene mai chiamato il distruttore.
sbirish.

 esce?
in generale è vero. Ma tu considerala solo una comodità per l'utente, e 
scrivi sempre codice per deallocare la memoria
-- 
  < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
      Don't stand, REACT!      version 0.1.5. C, C++ and ASM developers
                               and beta testers are welcome!

 lascia scrivere le graffe con ctrl + alt + shift + è
Anche io uso pan.
Come da standard:
{ = AltGr + 7 (non nel tastierino numerico)
} = AltGr + 0 (non nel tastierino numerico)