Hello!
I have just discovered a way to use the private implementation idiom
(pimpl), without the overhead of dynamic memory allocation. For those of
you who don't know what this is, Wikipedia has a nice article you can
read. Anyway, I discovered that if you make all members in the
implementation class mutable, you can in fact use this idiom without any
"unnecessar y" memory allocation. Here's a minimal example of the method:
// In the header of your class called Line
#include <string>
class Line
{
public:
Line(const std::string& name);
const std::string& GetName() const;
void SetName(const std::string& s);
private:
// Private implementation idiom:
// all member variables are hidden in this class
class LineImpl;
const LineImpl& m_pimpl; // normally a non-const pointer
};
// and in your implementation file:
#include "Line.h"
// Here we define the class with the member variables
class Line::LineImpl
{
public:
LineImpl(const std::string& s) : m_s(s) {}
// all methods need to be const here
const std::string& GetName() const { return m_s; }
void SetName(const std::string& s) const { m_s = s; }
private:
mutable std::string m_s; // the trick! all members are mutable
};
// create the pimpl instance without using new
Line::Line(cons t std::string& s) : m_pimpl(LineImp l(s)) {}
// forward all member functions to the private implementation
const std::string& Line::GetName() const
{
return m_pimpl.GetName ();
}
void Line::SetName(c onst std::string& s)
{
m_pimpl.SetName (s);
}
Ok experts, what do you all think? This method sacrifies
const-correctness for some extra speed. Is it worth it?
--
Daniel
I have just discovered a way to use the private implementation idiom
(pimpl), without the overhead of dynamic memory allocation. For those of
you who don't know what this is, Wikipedia has a nice article you can
read. Anyway, I discovered that if you make all members in the
implementation class mutable, you can in fact use this idiom without any
"unnecessar y" memory allocation. Here's a minimal example of the method:
// In the header of your class called Line
#include <string>
class Line
{
public:
Line(const std::string& name);
const std::string& GetName() const;
void SetName(const std::string& s);
private:
// Private implementation idiom:
// all member variables are hidden in this class
class LineImpl;
const LineImpl& m_pimpl; // normally a non-const pointer
};
// and in your implementation file:
#include "Line.h"
// Here we define the class with the member variables
class Line::LineImpl
{
public:
LineImpl(const std::string& s) : m_s(s) {}
// all methods need to be const here
const std::string& GetName() const { return m_s; }
void SetName(const std::string& s) const { m_s = s; }
private:
mutable std::string m_s; // the trick! all members are mutable
};
// create the pimpl instance without using new
Line::Line(cons t std::string& s) : m_pimpl(LineImp l(s)) {}
// forward all member functions to the private implementation
const std::string& Line::GetName() const
{
return m_pimpl.GetName ();
}
void Line::SetName(c onst std::string& s)
{
m_pimpl.SetName (s);
}
Ok experts, what do you all think? This method sacrifies
const-correctness for some extra speed. Is it worth it?
--
Daniel
Comment