Is it possible to forward declare a typedef'ed anonymous struct?

Sorry, the main function is not a good example, better:

int _tmain(int argc, _TCHAR* argv[])
{
      myStruct s;
      s.x =  5;
      return 0;
}

Hi evilrix,

I don't think it's possible in a direct way. Unfortunateley I cannot proof it by posting a link to a spec or something, but I think at least one good reason against it is that a typedef'ed name can be a 'void' - since it's not possible to declare a reference to void this isn't possible.

How do you intend to use this? Do you need to use a 'MyStruct&' within your code's header in own functions? Then maybe a forwarded struct can help you, i.e.:

// in header
> struct _MyStruct;
> void foobar( _MyStruct& m );

// in cpp
> typedef struct {} MyStruct;
>
> struct _MyStruct : public MyStruct {};
>
> void foobar( _MyStruct& m )
> {
>  ...
> }


@jaime_olivares: I don't think this first sample is of any help since the struct in question is an anonymous struct - otherwise it would be simple.


ZOPPO

Jaime, that isn't modelling the problem and wouldn't work anyway since you can't create an instance of a forward declared object only a pointer or a reference.

The struct is anonymous -- it has no tag! This models the problem...

// Forward declare -- how?
// This is what I want to do, but as myStruct is a typedef and NOT a struct so I can't. 
struct myStruct;
 
int main()
{
      myStruct * s; // You can only define a pointer or reference for a forward declared type.
}
 
typedef struct // anonymous (it has no tag)
{
public:
      int x;
} myStruct;
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

>> How do you intend to use this? Do you need to use a 'MyStruct&' within your code's header in own functions?
Example below...

struct DBHANDLE; // This fails because DBHANDLE is a typedef of an anonymous struct :(
 
class SomeDB : public IDatabase
{
    DBHANDLE * pdb_; // This is only ever 'used' in the .cpp file so the definition of DBHANDLE doesn't need to be known here but I can't forward declare it
}
                                              

1:
2:
3:
4:
5:
6:

Hm - couldn't you implement this with a template? I.e. as in the example below?

template <typename T>
class _SomeDB : public IDatabase
{
    T * pdb_;
public:
	void foo();
};
 
template <typename T>
void _SomeDB<T>::foo()
{
	pdb_ = new T;
}
 
typedef struct {} DBHANDLE;
 
typedef _SomeDB< DBHANDLE > SomeDB;
 
void foobar()
{
	SomeDB db;
 
	db.foo();
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

>> Hm - couldn't you implement this with a template? I.e. as in the example below?
Not really cos then all the implementation would need to go in the header (to satisfy the requirements of the 2 part instantiation of a template) and the type would need to be known when I define the concrete instance, moving the implementation detail outside of the class :)

Like I said, the solution is just to include the 3rd party header in my header... but I just want to know if I am overlooking something about forward declaring anonymous structs. I'm not really after an alternative solution -- I have one.

probably, DBHANDLE is just an int. If it gives you an idea...

I think, it is just a pointer. if you need to allocate a memory for it - 4 bytes.

maybe
#ifndef DBHANDLE
#define DBHANDLE unsigned int
#endif

>> probably, DBHANDLE is just an int. If it gives you an idea...

DBHANDLE was just an example I made up to show an example of what I am doing :)

In my specific case it is not an int it *IS* a struct -- I have the source code. But that is not in question. My question, my only question is, "Is it possible to forward declare a typedef'ed anonymous  struct?".

This question is largely academic. I am not looking for solutions to a problem (the code is now written and works just fine) I just want my curiosity quashed :)

Ok.
You are the professor. :)

Oh! Sorry. Genius. Congratulation!

>> Oh! Sorry. Genius. Congratulation!
Heh. thanks :)

As Genius you'd think I'd know this right? oops!

yes, you know. You know that it cannot be forward declared. Otherwise, who will make this struct anonymous.

Anonymous types provide a convenient way to encapsulate a set of read-only properties

It's about C#, but logically it should be right in C too.

Another links:

Anonymous Class Types

Other Data Types

but you know all that.

http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_closed.html#132

extern struct { } x;

Please take a look.

pgnatyuk,

Thanks but none of that really helps ;)

=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

BTW: Points will be awarded to anyone who can either tell me how to do this or direct me to an authorative source to confirm (as I suspect) that it cannot be done.

=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

The code below accurately models the problem.

g++ -g x.cpp -o xprog
x.cpp:13: error: conflicting declaration typedef struct foo foo
x.cpp:2: error: foo has a previous declaration as typedef struct foo foo
make: *** [xprog] Error 1

typedef struct {} foo;
 
struct bar
{
	bar();
	~bar();
	foo * pfoo_;
};
 
typedef struct
{
      int x;
} foo;
 
bar::bar() : pfoo_(0)
{
   pfoo_ = new foo;
}
 
bar::~bar()
{
   delete pfoo_;
}
 
int main()
{
	bar b;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

It will be two different MyStruct.
I've tried. But with a class.
What is so ugly in a simple void*?
Anyway he has found a solution that works.

>> What is so ugly in a simple void*?
Type unsafe... lots on messy (unsafe) casting involved.

>> You cannot forward declare a typedef for an anonymous struct
heh. I pretty much knew this was the case but really need to double check I wasn't being a pilchard :)

>> heh. I pretty much knew this was the case but really need to double check I wasn't being a pilchard :)

The standard doesn't allow it, because a forward declaration needs a tag (from the tag namespace) to unambiguously refer to the struct definition.

I know you knew it, but just wanted to confirm it :)

>> I know you knew it, but just wanted to confirm it :)
Appreciated... just -- what took you so long? ;)

Thanks I8.