Some thing about memory leaks

Some thing about memory leaks

Memory leaks , more important in Symbian C++ than that's in the PCS, But when you programs for a Media Processor which must run for there year or even much longer , you must consider Memory leaks seriously. How can avoid leaking?

 

1. remeber delete after you new operation

 

Just this is enougn? Of course , Many leaks come from this stimulation. but that's not all.

for E.G:

class ClassB {
private:
ClassA* ptr1; //pointer members
ClassA* ptr2;
public:
//constructor that initializes the pointers
//- will cause resource leak if second new throws
ClassB (ClassA val1, ClassA val2)
: ptr1(new ClassA(val1)), ptr2(new ClassA(val2)) {
}
//copy constructor
//- might cause resource leak if second new throws
ClassB (const ClassB& x)
: ptr1(new ClassA(*x.ptr1)), ptr2(new ClassA(*x.ptr2)) {
}
//assignment operator
const ClassB& operator= (const ClassB& x) {
*ptr1 = *x.ptr1;
*ptr2 = *x.ptr2;
return *this;
}
~ClassB () {
delete ptr1;
delete ptr2;
}
...
};

if an exception occurs inside a constructor,
destructors are only called for objects that have been fully constructed. This might result in a
resource leak if, for example, the first new was successful but the second was not.

 

2.How can I avoid such a possible resource leak?

you can use simply auto_ptr.(In Symbian , in my opinion ,The CleanStack works in the same machanism)

 

The code can write like the follows:

class ClassB {
private:
const std::auto_ptr<ClassA> ptr1; //auto_ptr members
const std::auto_ptr<ClassA> ptr2;
public:
//constructor that initializes the auto_ptrs
//- no resource leak possible
ClassB (ClassA val1, ClassA val2)
: ptr1 (new ClassA(val1)), ptr2(new ClassA(val2)) {
}
//copy constructor
//- no resource leak possible
ClassB (const ClassB& x)
: ptr1(new ClassA(*x.ptr1), ptr2(new ClassA(*x.ptr2)) {
}

const ClassB& operator= (const ClassB& x) {
*ptr1 = *x.ptr1;
*ptr2 = *x.ptr2;
return *this;
}
//no destructor necessary
//(default destructor lets ptr1 and ptr2 delete their objects)
...
};

 

Note, however, that although you can skip the destructor, you still have to program the copy
constructor and the assignment operator. By default, both would try to transfer ownership, which
is probably not the intention. In addition, and as mentioned on page 42, to avoid an unintended
transfer of ownership you should also use constant auto_ptrs here if the auto_ptr should
refer to the same object throughout its lifetime