class-in-a-typedef-in-a-class circular trouble

[Jacek Dziedzic]

Hello!

I'm creating a class that has a static method which would
compute a lookup table needed later by all members of the class.
The problem is, the lookup table is composed of records and one
of the record fields is the class itself, i.e. I'm aiming at
something like:

typedef struct {
my_class instance;
int lookup_value;
} lookup_record;

class my_class {
private:
int some_internal_v ar;
static lookup_record lookup_table[1000];
public:
static void prepare_lookup_ table();
// ...
};

but that won't compile with "my_class is used as a type but is
not defined as a type". All right then, the compiler doesn't
know yet, what my_class is. So I tried to add a line with

class my_class;

above it all, but then it says that "field my_class has
incomplete type". If I try to put the typedef after the
class, then the class declaration does not know what the
typedef is. Also classes and typedefs won't accept extern.

What do I do? This all is, btw, in a header file.

tia,
- J.

[Gavin Deane]

Jacek Dziedzic <[e-mail]> wrote in message news:<bj******* ***@korweta.tas k.gda.pl>...

Josephine Schafer wrote:

You need to tell the compiler the size of the class also then.
How is to deduce the size just by looking at a forward declaration.

I thought that a forward declaration would tell the compiler to
"look somewhere else for the precise class declaration and
compute the size", but it seems it's not *that* smart, right?

No, it can't do that. Every translation unit (roughly, a translation
unit is a source file and all its includes) is compiled separately. As
each TU is compiled, the compiler has no knowledge whatsoever of any
other TU. When you forward declare a class, the class definition does
not have to appear later in the same TU (it can be in a different -
one that's the point :-) ) even though that happens to be the case in
your example. So in general, the "somewhere else" you want the
compiler to look is not available.

So one way to solve your problem is to store a pointer to my_class in your
struct instead of the object itself.
my_class *pInstance;.
This way compiler can live just with the forward declaration (i.e.without
seeing it's actual definition)

Yes, I thought about this, but I don't think I can afford such
overhead in memory and in speed (it's a look-up table supposed
to speed things up, after all) that would be introduced by
one extra dereferencing. I think I'll just forget about class
neatness and store the internal class variable (an int)
in the lookup record instead of storing the class itself.
That won't look good, but would be effective.

Be wary of confusing your design to save speed unless and until you
have proven that the "slow" way is too slow to be acceptable.
Premature optimisation being the root of all evil and all that.

GJD

[Ivan Vecerina]

"Jacek Dziedzic" <[e-mail]> wrote in message
news:bj******** **@korweta.task .gda.pl...
| Thanks a lot, Ivan! Your namespace idea worked just fine!
I'm glad it worked.

While there are alternatives (kudos to Tom, I forgot about
the solution he mentioned), I think it is usually a good
idea to move private static members into an anonymous
namespace in the implementation file. Especially when this
data involves additional type declarations.
This way there are completely hidden from users, and
will cause less compile time overhead (and less
recompilations when they are modified).

Cheers,
Ivan
--
http://ivan.vecerina.com