CODEWITHSUNDEEP
c++
Troncador
Troncador

Reputation: 3556

Split a C++ class declaration

I want to know if I can split a C++ class declaration

Original class

    class P
    {
        private: 
           int id;
           //some really secret method
           int secretMethod();
       protected:
           int x;
       public:
           P();
           int getX();
    };

I want to show in the .h only the public and protected method and attributes, and declare somewhere else the private, where the user of the class can't see it.

Wanted class declaration:

    class P
    {
       protected:
           int x;
       public:
           P();
           int getX();
    };

Edit: I want that for:

  1. I can change the implementation of the class and for the user of the class is transparent
  2. Is easier for the user to see less information than more
  3. If I change the implementation of the class, change the private atributes and method I don't want to change the .h for the user of the class

Upvotes: 6

Views: 9743

Answers (5)

HuskyDucky
HuskyDucky

Reputation: 1288

You can heritage the second part like this:

//Class P_Hetitage definition

class P_Heritage {
      protected:
                int id;
                //some really secret method
                int secretMethod();
}

//Class P definition

class P : private P_Heritage {
      protected:
                int x;
      public:
             P();
             int getX();
};

Below a straightforward explanation how inheritance works:

Inheritance the class P_Heritage as:

public

  1. public elements are public to class P
  2. protected elements are private to class P

private

  1. public elements are private to class P
  2. protected elements are private to class P

P_Heritage's private elements can not be seen by class P

Upvotes: 0

Edward Strange
Edward Strange

Reputation: 40877

Yes, it is possible but not in the direct kind of way. Here is what you do:

my_object.h:

struct my_object {
  void fun();

  my_object();
  my_object(my_object const&);
  ~my_object();

  my_object& operator = (my_object);

protected:
  void pfun();

private:
  struct impl;
  std::unique_ptr<impl> pimpl;
};

my_object.cpp:

struct my_object::impl {
  void fun() { do stuff...}

  void pfun() { do other stuff... }

  int private_member;
};

my_object::my_object() : pimpl(new impl) {}
my_object::my_object(my_object const& o) : pimpl(new impl(*o.pimpl) {}
my_object::~my_object() {}

my_object& my_object::operator = (my_object o) { swap(pimpl, o.pimpl); return *this; }

void my_object::fun() { pimpl->fun(); }
void my_object::pfun() { pimpl->pfun(); }

As you can see, it's a lot of work and requires the heap. Everything in balance...use when you need to.

Upvotes: 6

Benjamin Lindley
Benjamin Lindley

Reputation: 103733

If your purpose is to simply reduce clutter in your header, you can include a file in the middle of your class:

class P
{
#include "P.private_parts"

   protected:
       int x;
   public:
       P();
       int getX();
};

Upvotes: 1

Puppy
Puppy

Reputation: 146968

It is not possible to genuinely split a C++ class definition. All that you can do is implement a run-time abstraction which will firewall the source code by using a disgusting hack like PIMPL.

Upvotes: 0

ervinbosenbacher
ervinbosenbacher

Reputation: 1780

Something like this?

class P
{
private:
    class Impl
    {
    public:
       int id;
       //some really secret method
       int secretMethod();
    };

private:
    Impl* _pimpl;

protected:
    int x;

public:
    P() : _pimpl(new P::Impl()) {}
    ~P() { delete _pimpl; } 
    int getX();

};

Upvotes: 0

Related Questions