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.