avoiding multiple definition error

[joe.user0]

Your C program is using library libA which has a structure
struS.

You need to modify struS but may not touch the library. How
can your program redefine the structure struS while keeping
the compiler happy?

[Ian Collins]

jo*******@lycos .com wrote:

Your C program is using library libA which has a structure
struS.

You need to modify struS but may not touch the library. How
can your program redefine the structure struS while keeping
the compiler happy?

It can't.

--
Ian Collins.

[jaysome]

On 10 Jan 2007 23:51:26 -0800, jo*******@lycos .com wrote:

>
Your C program is using library libA which has a structure
struS.

You need to modify struS but may not touch the library. How
can your program redefine the structure struS while keeping
the compiler happy?

This could be accomplished if struS is declared with external linkage
and its type is visible to your C program. Something like the
following snippets:

/* libA.h */
struct foo {int bar;}

/* libA.c */
struct foo struS;

/* yourcprogram.c */
extern struct foo struS;
struS.bar = 0;

Note that if struS was defined with internal linkage (like it arguably
should have been):

/* libA.c */
static struct foo struS;

then there is no standard way to modify struS without "touching the
library" (e.g., calling a function that modifies struS).

Regards
--
jay

[Martin Golding]

On Wed, 10 Jan 2007 23:51:26 -0800, joe.user0 wrote:

Your C program is using library libA which has a structure struS.
You need to modify struS but may not touch the library. How can your
program redefine the structure struS while keeping the compiler happy?

Your subject implies a name conflict, that is, you want to name
something struS that's unrelated to libA, but use other features
of libA. In that case, just rename the struct when you include the
header file

#define struS libAstruS
#include <libAheader.h >
#undef struS

If you really mean you want to modify struS to your own taste, the
standard allows you _only_ to add fields to the end _of your own copies_
of struS:

#define struS libAstruS
#include <libAheader.h >
#undef struS

--- then either (A):

struct struS {
... libA fields of struS ...
... your new fields ...
};

--- or (B):

struct struS {
libAstruS libAbits;
... your new fields ...
};

The second form protects you from changes to the library's definition,
and allows you to call properly prototyped functions more cleanly.
With (A), you'll have to cast:

struct struS mystruS;
libAfunc((struc t libAstruS *) &mystruS);

with (B), just name the library's part:

struct struS mystruS;
libAfunc(&mystr uS.libAbits);
Neither solution is more to my taste than leaving the library name alone
and incorporating the libA struS into a struct of your very own (C):

stuct mystruS {
struS libAstruS libAbits;
... your new fields ...
};

struct mystruS mystruS;
libAfunc(&mystr uS.libAbits);
In any of the cases, you'll have to do some fiddling if the library
creates struSes. For example, if the libA header declares a function
struct struS libAnew_struS(v oid);
(A)
struct struS mystruS;
struct libAstruS *pstruS = (struct libAstruS *) &mystruS;

*pstruS = libAnew_struS() ;

(B)
struct struS mystruS;
mystruS.libAbit s = libAnew_struS() ;

(C)
struct mystruS mystruS;
mystruS.libAbit s = libAnew_struS() ;

If the library exports global struSes, you're out of luck entirely.
eg, given (B)

extern struS gblstruS;

gblstruS.libAfi eld = xxx; /* OK */
gblstrus.newfie ld = xxx; /* abort, if you're very lucky */

In that case, declare your own structs containing pointers to libA struSes.

Martin
--
Martin Golding DoD #0236 | fo*****@comcast .net
Always code as if the person who ends up maintaining your code will be a
violent psychopath who knows where you live.