C / C++ / MFC

22-Dec-09 8:44

I've got a problem trying to define / restrict function accessibility in C++ classes. I'm using the VS2008 compiler, since that does make a difference -- there's a solution using a friend helper class that worked prior to VS2005 but doesn't any more since MS fixed a bunch of conformity error in the later compilers.

I have a base class, an asynchronous callback coming from the OS, and a derived class. The async callback needs to manipulate some of the private variables in the base class. The derived class must NOT be allowed to manipulate those variables and, as such, cannot be allowed to call the function that does so.

My question is how do I modify the following code snippets to do what I want. Don't worry about re-entrancy issues with the callback - that's been removed for the sake of clarity.

baseclass.h

class BaseClass
{
public:
    BaseClass ();
    void BaseFuncA ();

private:
    // various member functions and variables
    void CallbackFuncA ();
};

baseclass.cpp

void CALLBACK AsyncCallbackFunc (DWORD dwParam)
{
    ((BaseClass *) dwParam)->CallbackFuncA ();
}

void BaseClass::BaseClass ()
{
    // init OS func passing in <code>this</code> as parameter for callback
}

void BaseClass::CallbackFuncA ()
{
    // do some stuff with the private vars in the class
}

derivedclass.h

#include "BaseClass.h"
class DrvClass : public BaseClass
{
public:
    DrvClass ();

    void DerivedFuncA ();
};

derivedclass.cpp

void DrvClass::DerivedFuncA ()
{
    BaseFuncA ();
    // more stuff
}

Thanks!!
Judy

Be wary of strong drink. It can make you shoot at tax collectors - and miss.
Lazarus Long, "Time Enough For Love" by Robert A. Heinlein

Richard Andrew x6422-Dec-09 10:25

Richard Andrew x64

22-Dec-09 10:25

How about overriding the function in your derived class, and having the override perform something meaningless, while only the base implementation of the function does the variable manipulation?

JudyL_MD22-Dec-09 11:14

22-Dec-09 11:14

It's more a question of preventing the derived classes from calling the function. I'm looking for a compile-time way to enforce my rule rather than depending on the goodness of the derived class'es writer -- me in this case, so this is something of an academic discussion since I am, by definition, most definitely good. Wink | ;)

The basic issue is how to make the function private with respect to derived classes yet somehow allow a callback who only has a class pointer to call the function. I can't pass a direct pointer to the function as the parameter to the callback because of the nature of the OS function that sets up the callback. It only takes one parameter but can initiate multiple callbacks. I only showed one in my example code to make life simpler.

Judy

Be wary of strong drink. It can make you shoot at tax collectors - and miss.
Lazarus Long, "Time Enough For Love" by Robert A. Heinlein

Richard Andrew x6422-Dec-09 11:17

Richard Andrew x64

22-Dec-09 11:17

I see. I wish I knew a way to do that. Good luck. Blush | :O

Tim Craig22-Dec-09 14:07

22-Dec-09 14:07

Sounds like the base and derived classes are inverted. The data you want to protect should be in the derived class and not in the base class. Then you could pass in the pointer to an instance of the derived class to the OS function. Depending on your other needs, the base class could implement the do nothing function that accesses the private data it doesn't have. If you need polymorphism, that fuction could be virtual and possibly even abstract.

You measure democracy by the freedom it gives its dissidents, not the freedom it gives its assimilated conformists.

JudyL_MD22-Dec-09 16:24

22-Dec-09 16:24

Tim Craig wrote:
Sounds like the base and derived classes are inverted.

The base class contains the basic communications logic for talking to a chunk of hardware, things like Initialize, Uninitialize, the low-level details of sending a series of bytes, and the asynchronous callbacks from the hardware detailing hardware state, along with get-type accessors for the derived classes to test the details maintained by the base class. The derived classes contain things like formatting and validating a particular class of message and then synchronously calling the base class to send that message. The base class needs to hide things like the OS handle to the hardware and the event used to synchronize access with the callbacks. I structured it this way because the same basic hardware can operate in different modes (not controlled by the base class), each of which requires a different messaging format but not a different low-level communication scheme.

Judy

Be wary of strong drink. It can make you shoot at tax collectors - and miss.
Lazarus Long, "Time Enough For Love" by Robert A. Heinlein

Tim Craig22-Dec-09 17:06

22-Dec-09 17:06

Maybe an inheritance hierarchy isn't what you need then. Instead of a "is-a" relationship with your base class, you derived classes should have a different base which has a "has-a" relationship with the current base?

You measure democracy by the freedom it gives its dissidents, not the freedom it gives its assimilated conformists.

Avi Berger22-Dec-09 18:49

Avi Berger

22-Dec-09 18:49

I'm half asleep, simple-minded, and can't figure out what I'm missing here.

Your program is separate from the OS, but is providing a callback to the OS. I would think that means that you have to be providing the OS with the address of your callback function. It looks like you are putting the callback implementation in the same compilation unit as the class in question. Why doesn't making your callback a private, static member of your class do the job?

Tim Craig22-Dec-09 18:58

Re: function access in base and derived classes [modified]

22-Dec-09 18:58

A static member wouldn't have access to the private data of a particular instance of the class.

You measure democracy by the freedom it gives its dissidents, not the freedom it gives its assimilated conformists.

Avi Berger22-Dec-09 19:21

Avi Berger

22-Dec-09 19:21

The callback gets a parameter which is a pointer to the particular class instance it is to deal with. Is it no longer allowed to use that pointer to access members of that particular instance?

modified on Wednesday, December 23, 2009 1:40 AM

Tim Craig22-Dec-09 21:36

22-Dec-09 21:36

True enough. But her main problem is that for whatever reason, good or bad, the derived classes shouldn't be able to see the private parts of the base class. Seems like a poor design to me but then it's not really clear why the requirement. Might just be a matter of documenting it so future developers know the runs on how to use the class and why. That stuff most developers never do. Sigh | :sigh:

You measure democracy by the freedom it gives its dissidents, not the freedom it gives its assimilated conformists.

JudyL_MD23-Dec-09 2:20

23-Dec-09 2:20

Tim Craig wrote:
But her main problem is that for whatever reason, good or bad, the derived classes shouldn't be able to see the private parts of the base class. Seems like a poor design to me but then it's not really clear why the requirement.

That requirement happens quite often for classes that deal with hardware. The base class implements the hardware interaction and the derived classes add all the validation / formatting / UI error handling / data processing on top of the hardware interaction. It's a hierarchy of adding functionality as you derive.

Think of the base class as an engine and the derived class as a car. The car must contain the functionality of the engine but it doesn't need access to the firing rate of the spark plugs and the gas flow regulator. It just needs a function that says SetOutputPower. Each different car will use the same engine.

I write lots of code that talks to hardware and usually, I don't have this problem. This situation is slightly different because of the way the interaction through the OS happens for this given piece of hardware. A solution is easy -- move those base-class members that the OS-triggered callbacks touch into module-level static variables (outside the base class) in the source file with the base class. I was seeing if there was a way to avoid this since it messes up the data encapsulation of the base class.

Judy

Be wary of strong drink. It can make you shoot at tax collectors - and miss.
Lazarus Long, "Time Enough For Love" by Robert A. Heinlein

Tim Craig23-Dec-09 9:31

23-Dec-09 9:31

I've dealt with a lot of hardware, too. Primarily instrumentation and now robots, that's why I suggested the "has-a", or maybe in this case "uses-a" or "controls-a", relationship with your hardware class. Instead of inheriting from the hardware, the more abstract class simply contains an instance of hardware class or a pointer to "the" instance depending on whether you allow more than one instance of the hardware to exist at a time. This way it only can use the public interface you provide yet still. It isn't a hardware abstraction class but a hardware control class.

In your car class, the car isn't really an engine, it's a collection of parts of which the engine is simply one. The car "has-a" engine. Maybe one of the more important parts but just a part like wheels, tires, windows. In your model the driver would inherit from car while in mine the driver becomes the car controller. The driver doesn't have to know or access all the nitty gritty details of how a car works (that make us MEs drool) but just understand the interface to drive it. Just like the car itself doesn't have to know what kind of engine it has, just the interface to the throttle, fuel system, etc, to get it running and control it.

You measure democracy by the freedom it gives its dissidents, not the freedom it gives its assimilated conformists.

JudyL_MD23-Dec-09 10:08