How do you exchange private data with Pimpl without exposing your internals?

Question

If you have an object B that needs a copy of a private member of an object A, and the private member is hidden by a Pimpl, how do you make it happen without exposing your internals? // Foo.h

class Foo
{
private :
  struct impl ;
  impl * pimpl ;
};

// Foo.cpp
struct impl { std::string data; }

//main.cpp
Foo A;
Foo B;
// I want A::pimpl->data copied to B::pimpl->data and I don't want std::string exposed in my Foo header.

I can't see how without exposing std::string in the Foo header. — joey_89, May 09 '11 at 12:20
@joey: you mean, you want your clients to access the string without knowing it's a string? — André Caron, May 09 '11 at 12:44
@joey: see my answer for a solution that avoids exposing `std::string` in the `Foo` header file. — André Caron, May 09 '11 at 12:52

score 7 · Accepted Answer · answered May 09 '11 at 12:23

7

// header
class Foo
{
    public:
       void Copy( const Foo & );
    private :
       struct impl ;
       impl * pimpl ;

};

//cpp file
struct impl {std::string data; }

void Foo::Copy( const Foo & f ) {
      pimpl->data = f.pimpl->data;
}

answered May 09 '11 at 12:23

How can I acess pimpl in f since it's private ? – joey_89 May 09 '11 at 12:36
1

@joey You need to re-read your C++ text book. Access control in C++ is per class, not per class instance. – May 09 '11 at 12:38
@joey_89: It's a member function. You can access private data. – Puppy May 09 '11 at 12:38

score 3 · Answer 2 · answered May 09 '11 at 12:24

3

Foo needs to implement a constructor, a copy constructor, a destructor and an assignment operator, doing the "right thing" - allowing you to do e.g. 'A = B;'

// Foo.h
struct FooImpl;
class Foo
{
  Foo(Foo const &);
  Foo();
  ~Foo();
  Foo & operator=(Foo const & RHS);
private:
  FooImpl * pimpl;
};

// Foo.cpp
struct FooImpl {std::string data; }

Foo & Foo::operator=(Foo const & RHS) {
  *pimpl = *RHS.pimpl;
  return *this;
}
Foo::Foo(Foo const & V) {
  pimpl = new FooImpl(*V.pimpl);
}

Foo::Foo() {
  pimpl = new FooImpl;
}

Foo::~Foo() {
  delete pimpl;
}

Now you can safely do:

Foo A;
Foo B;
A = B;

answered May 09 '11 at 12:24

Erik

88,732
13
198
189

I don't want to copy all the object, only a private member. – joey_89 May 09 '11 at 12:37
2

if you speak on doing the right thing, then please use a smart pointer rather than manual clean-up :) – Matthieu M. May 09 '11 at 12:43
@joey_89: Then use the method unapersson describes – Erik May 09 '11 at 12:46
@Matthieu M.: Yep, but then I'd change his class instead of explaining what's lacking. – Erik May 09 '11 at 12:47
you would, but you would also instill good practice. I personally think it's worth it :) But to each its own! (And belated congratulations for the 20k mark) – Matthieu M. May 09 '11 at 12:51

score 0 · Answer 3 · answered May 09 '11 at 12:50

Other issues aside (copy constructor, ec.), if you want to access impl::data without imposing the <string> header to all your clients, you can do something like the following:

// Foo.h
class FooUtil;
class Foo
{
friend class FooUtil;
private :
  struct impl ;
  impl * pimpl ;
};

// FooUtil.h
#include <string>
class FooUtil
{
public:
    static std::string data_of(const Foo&);
};

// Foo.cpp
struct impl { std::string data; }
std::string FooUtil::data_of(const Foo& foo)
{
    return foo.impl->data;
}

//main.cpp
Foo A;
Foo B;

This is a hack-ish work-around for having a std::string Foo::data() const member function. The idea is that you can have the <string> header included by only the clients who need it.

Disclaimer: I really don't like this approach. It's very inelegant and is unlikely to really increase compile times. Some compilers cache (or pre-compile) standard library headers so as to help people avoid this kind of mess.

How do you exchange private data with Pimpl without exposing your internals?

3 Answers3