How to disclose class interface but hide implementation

[vict]

I want to write a C++ class, like this:

In MyClass.h:

class CMyClass
{
public:
CMyClass();

int MyFun(int a, int b);

protected:
int m_iData;
BOOL m_bFlag;
}

In MyClass.cpp

CMyClass::CMyClass()
{
// Some initialization codes
}

int CMyClass::MyFun(int a, int b)
{
// Implemenation of MyFun
}

Now I want to let another developer to use CMyClass, but only want him to be able to:

1. Construct a CMyClass object.
2. Call MyFun function.

and PREVENT him to:

1. Know the implementation of the CMyClass object.
2. Know the existance of the member variable m_iData and m_bFlag.

Now I can put MyClass.h and MyClass.cpp in a static library and compile it, then send the compiled static library as well as only the MyClass.h to the developer, but he will still able to know the protected memory variables m_iData and m_bFlag, and based on them, he can guess the implementation of the MyFun. How to prevent this?

Thanks

[coder777]

Like so:

In MyClass.h:

class CMyClass
{
public:
CMyClass();

int MyFun(int a, int b);

protected:
struct Data *m_D;
};

In MyClass.cpp

struct Data
{
int m_iData;
BOOL m_bFlag;
};

CMyClass::CMyClass() : m_D(new Data)
{
// Some initialization codes
}

int CMyClass::MyFun(int a, int b)
{
// Implemenation of MyFun
}

[vict]

Thank you. I understand that is called "pimpl idiom", isn't it?

[shacktar]

Then forward declare Data

struct Data;

class CMyClass
{
public:
    CMyClass();

    int MyFun(int a, int b);

protected:
    struct Data* m_D;
};

This is known as the "Pimpl Idiom".

[coder777]

@shacktar
line 1 isn't needed since line 11 is already a forward declaration

[shacktar]

That's the first time I've seen a forward declaration like that. I was going with the assumption that the OP couldn't compile the code (a comment that's been edited out).