---

Hej,

hvis jeg har følgende klasse

class A {
public:
A() {}
~A() {}

list<int> someList;
}

og laver et nyt objekt af type A

A *a = new A();

, sætter en masse elementer ind i a->someList og senere sletter a med
delete a, hvad sker der så med den hukommelse som må være blevet
allokeret ved indsættelserne i someList? Skal jeg i destructoren for A
tømme listen?

/Andreas

---

Den Mon, 14 Feb 2005 16:01:46 +0100 skrev Andreas Andersen:
> Hej,
>
> hvis jeg har følgende klasse
>
> class A {
> public:
> A() {}
> ~A() {}
>
> list<int> someList;
> }
>
> og laver et nyt objekt af type A
>
> A *a = new A();
>
> , sætter en masse elementer ind i a->someList og senere sletter a med
> delete a, hvad sker der så med den hukommelse som må være blevet
> allokeret ved indsættelserne i someList? Skal jeg i destructoren for A
> tømme listen?

Naturligvis.

Hver gang du har en new, skal du have en delete.

Mvh
Kent
--
Help test this great MMORPG game - http://www.eternal-lands.com/

---

"Kent Friis" <nospam@nospam.invalid> wrote in message
news:4210c546$0$29284$14726298@news.sunsite.dk...
| Den Mon, 14 Feb 2005 16:01:46 +0100 skrev Andreas Andersen:
| > Hej,
| >
| > hvis jeg har følgende klasse
| >
| > class A {
| > public:
| > A() {}
| > ~A() {}
| >
| > list<int> someList;
| > }
| >
| > og laver et nyt objekt af type A
| >
| > A *a = new A();
| >
| > , sætter en masse elementer ind i a->someList og senere sletter a med
| > delete a, hvad sker der så med den hukommelse som må være blevet
| > allokeret ved indsættelserne i someList?

Generelt håndtere standard biblioteket altid din hukommelse, så
længe du arbejder med typer, som selv håndtere deres hukommelse.
(fx, all klasser i std biblioteket, alle primitive type)

| Skal jeg i destructoren for A
| > tømme listen?
|
| Naturligvis.

Nej, det er forkert. Destruktoren på stack-objecter i dine klasser kaldes
automatisk.

| Hver gang du har en new, skal du have en delete.

Tja, det er sådan set ikke forkert, men heller ikke helt, hvad man normalt
gør.
Det bedste er at automatisere håndtering af resourcer, også memory. Derfor
bør du brugen smart pointer:

boost::scoped_ptr<A> a( new A );

// ... ingen delete overhovedet

Normalt er en explicit delete udtryk for at dit program er fejlbehæftet; det
hænger
sammen med exception-safety; hvis en exception optræder inden du når at
kalde delete, så får du aldrig frigjort hukommelsen...dette sker aldrig med en
smart pointer.

See http://www.boost.org/libs/smart_ptr/smart_ptr.htm
for en række gode smart pointere. De to vigtigste er scoped_ptr
og shared_ptr.

mvh

Thorsten

--
Thorsten Ottosen
----------------------------
Dezide Aps -- Intelligent Customer Support:
www.dezide.com

Aalborg University --- Decision Support Systems:
http://www.cs.aau.dk/index2.php?content=Research/bss

C++ Boost:
www.boost.org

C++ Standard:
http://www.open-std.org/JTC1/SC22/WG21/

---

Thorsten Ottosen wrote:
> Nej, det er forkert. Destruktoren på stack-objecter i dine klasser kaldes
> automatisk.

Ok - det var vel egentlig bare det jeg skulle vide. Tak.

> See http://www.boost.org/libs/smart_ptr/smart_ptr.htm
> for en række gode smart pointere. De to vigtigste er scoped_ptr
> og shared_ptr.

Det ser da "smart" ud. Er de forskelle i effektivitet, de angiver, noget
man overhovedet kan mærke i praksis?

/Andreas

---

Andreas Andersen" <andreasa.fjerndette@daimi.au.dk> wrote in message
news:cusn93$29j7$1@news.cybercity.dk...
| Thorsten Ottosen wrote:
| > Nej, det er forkert. Destruktoren på stack-objecter i dine klasser kaldes
| > automatisk.
|
| Ok - det var vel egentlig bare det jeg skulle vide. Tak.

HTH

| > See http://www.boost.org/libs/smart_ptr/smart_ptr.htm
| > for en række gode smart pointere. De to vigtigste er scoped_ptr
| > og shared_ptr.
|
| Det ser da "smart" ud. Er de forskelle i effektivitet, de angiver, noget
| man overhovedet kan mærke i praksis?

Det afhænger af hvor mange man har og brugen af dem. Men som regelt
vil jeg tro svaret er "nej".

scoped_ptr har intet overhead; brug den til at holde pointere som
member variables. Den har den fordel at den ikke kan kopieres, så
de default generede copy operationer ikke virker.

I de fleste andre tilfælde er shared_ptr det rigtige valg.
(når man ser bort fra mit nye boost lib, som kommer snart)

-Thorsten

---

"Thorsten Ottosen" <nesotto@cs.auc.dk> writes:

> Nej, det er forkert. Destruktoren på stack-objecter i dine klasser kaldes
> automatisk.

Men hvis det havde været en

std::list<Foo*> someList;

havde han selv skulle slette medlemmerne i destructoren til A
(forudsat at A var ejeren).

> Det bedste er at automatisere håndtering af resourcer, også memory. Derfor
> bør du brugen smart pointer:
>
> boost::scoped_ptr<A> a( new A );

Er det bedre end

std::auto_ptr<A> a( new A ); // No boost needed!

som er hvad jeg bruger i dag?

---

Den Tue, 15 Feb 2005 10:37:42 +0100 skrev Per Abrahamsen:
> "Thorsten Ottosen" <nesotto@cs.auc.dk> writes:
>
>> Nej, det er forkert. Destruktoren på stack-objecter i dine klasser kaldes
>> automatisk.
>
> Men hvis det havde været en
>
> std::list<Foo*> someList;
>
> havde han selv skulle slette medlemmerne i destructoren til A
> (forudsat at A var ejeren).

Ups, jeg overså lige at det ikke var en pointer-liste. Men på den anden
side burde "hver gang du har en new skal du også have en delete" jo
indikere at når man ikke har en new, skal man naturligvis heller ikke
have en delete.

Mvh
Kent
--
Help test this great MMORPG game - http://www.eternal-lands.com/