Advice on wrapping data

[Dirk Bruere at Neopax]

I have data concerning h/w capabilities.
I intend to use a header file to do #defines, and put it into a class CHardware
along with serialisation function for the variables assigned values from the .h.
So, I get code like...

CHardware hardware;
hardware.serialise();
etc

which isn't a problem.

However, functions in other clesses need to have access to this data as well.
The obvious way is to use the .h file with it's #defines. However, I would
rather the other classes accessed it from a global instance of CHardware. Is
this possible or advisable?

--
Dirk

The Consensus:-
The political party for the new millenium
http://www.theconsensus.org

[Luke Meyers]

Argh, I composed a whole nice reply for you and google ate it! Okay,
you get the short version without nifty code snippets. In fact, you
get bullet points.

* Don't use #define for constant data. Use const variables. In cases
like this, where the data is associated with a class, use static const
variables so that the data is associated with the class itself. You
don't need a global instance, just ClassName::ConstantName.
* Check out the Boost serialization library and understand what it can
do for you before you go off inventing your own. Boost's
implementation is usually a better way to go than a homebrew.

Luke

[Phil Staite]

As Mr. Meyers pointed out, don't use #define for constant data.

Consider this approach:
foo.H

class foo
{
public:
int getCharacteristicA() const;
int getCharacteristicB() const;
int getCharacteristicC() const;
};
foo.C

static const int valueA = 0;
static const int valueB = 1;
static const int valueC = 2;
int foo::getCharacteristicA() const { return valueA; }

int foo::getCharacteristicB() const { return valueB; }

int foo::getCharacteristicC() const { return valueC; }
This way client code of the class gets the public interface, and has to
go through your instance to get the values. The actual values are out
of the way, static file-scope to just foo.C.

[Luke Meyers]

Getters are a bit excessive for retrieval of constants. It's just
extra boilerplate, more code to maintain (or forget to maintain), and
more work for the compiler to optimize out. But if you must, they
should at least be static inline. Since statics would be initialized
in the cpp anyway, you maintain the benefit of not recompiling user
code if the values change.

Luke