the leak of the memory in c++ 03

The Leak of the Memory in C++

In this chaper I will introduce a new smart pointer which is scoped_ptr;

It likes auto_ptr but better. When peopel use auto_ptr, sometimes they forget

that auto_ptr alread is empty, like this;

auto_ptr<Person> p1(new Person);
auto_ptr<Person> p2 = p1;
cout << p1->name() << endl;

In above situation, p1 is empty pointer after it gives pointee to p2. It

will produce some error.

But scoped_ptr can't give pointee to any pointer, so it will be better and

safer in some cases.

Now I'll introduce some special pattern to you, I say special, because in

normal cases, it just used in C++; In articles which I wrote before, I avoided

to use operator of delete, but I still use new operator, in this article I'll

introduce method which can help us to avoid use new operator.

Now let us welcome our pattern: PIMPL, it means Pointer to Implement. It

looks like below.

PersonImpl.h

class PersonImpl
{
public:
PersonImpl()
{
cout << "I'm constructed" << endl;
}
~PersonImpl()
{
cout << "I'm destructed!" << endl;
}

private:
int age_;
string name_;
public:
const string& getName()const
{
return name_;
}
void setName(const string& name)
{
name_ = name;
}

int getAge()
{
return age_;
}

void setAge(int age)
{
age_ = age;
}
};

Person.h

using namespace std;
using namespace boost;

class Person
{

public:
Person() :
personPtr_(new PersonImpl)
{}

~Person()
{
};
private:
scoped_ptr<PersonImpl> personPtr_;

public:
int getAge()
{
return personPtr_->getAge();
}

void setAge(int age)
{
personPtr_->setAge(age);
}

const string& getName()const
{
return personPtr_->getName();
}

void setName(const string& name)
{
personPtr_->setName(name);
}
};

main.cpp

using namespace std;
using namespace boost;

int main(int,char**)
{
Person person;
return 0;
}

In above code, I did not implement Person directly, instead of a smart

pointer which point a class which implement Person. So we can use class Person

just like I use it in main function without new neither delete operators.