How to restrict 'some' code from getting compiled/built? (without #define)

[Sachin Garg]

I need to build two executables from my code, one having all the code (and
thus application features) and other not having it all. How to best manage
the code that shouldn't go in one of the executables?

My first thought is to use conditional compilation with #define and #ifdef
etc but its getting messy, are there better ways to manage this?

The problem in detail:

#. There is a class A with virtual foo1 and foo2
#. There are 'lots' of derived classes of A which implement foo1 and foo2
#. Executable1 needs to use both foo1 and foo2
#. Executable2 only needs to use foo1, never needs foo2

How to make sure that all the foo2 code never gets into executable2? Lots of
#ifdefs can be used for this but is there a better solution? Maybe some
clever use of templates? Something else less complicated?

Thanks

[Sam]

Sachin Garg writes:

The problem in detail:

#. There is a class A with virtual foo1 and foo2
#. There are 'lots' of derived classes of A which implement foo1 and foo2
#. Executable1 needs to use both foo1 and foo2
#. Executable2 only needs to use foo1, never needs foo2

How to make sure that all the foo2 code never gets into executable2? Lots of
#ifdefs can be used for this but is there a better solution?

Yes: organizing your code.

Put all code derived from foo2 into separate translation units. Do not
include those translation units in your second executable.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (GNU/Linux)

iEYEABECAAYFAkhJtn4ACgkQx9p3GYHlUOLH0QCfTsTTQQbUQx/Xn4UYTvOAD5gd
RyMAmgIKTAyCS6RaRnSt2z4hqnybQwiI
=SJfa
-----END PGP SIGNATURE-----

[sheffmail]

On Jun 7, 1:37 am, "Sachin Garg" <[e-mail]:

I need to build two executables from my code, one having all the code (and
thus application features) and other not having it all. How to best manage
the code that shouldn't go in one of the executables?

My first thought is to use conditional compilation with #define and #ifdef
etc but its getting messy, are there better ways to manage this?

The problem in detail:

#. There is a class A with virtual foo1 and foo2
#. There are 'lots' of derived classes of A which implement foo1 and foo2
#. Executable1 needs to use both foo1 and foo2
#. Executable2 only needs to use foo1, never needs foo2

How to make sure that all the foo2 code never gets into executable2? Lots of
#ifdefs can be used for this but is there a better solution? Maybe some
clever use of templates? Something else less complicated?

Thanks

Hm, don't know if that's what you want, but here's how it can be done:

template <bool Use>
class foo2
{
//implementation in case of it's not needed
}

template <>
class foo2<true>
{
//implementation in case of it's needed
}

template <bool Use>
class foo2derived : public foo2<Use>
{
//implementation in case of it's not needed
}

template <>
class foo2derived : public foo2<true>
{
//implementation in case of it's needed
}

Usage:

const bool UseFoo2 = ...;

foo2derived<UseFoo2f2d; //will compile the needed version of
foo2derived

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2008-06-06 23:37, Sachin Garg wrote:

I need to build two executables from my code, one having all the code (and
thus application features) and other not having it all. How to best manage
the code that shouldn't go in one of the executables?

My first thought is to use conditional compilation with #define and #ifdef
etc but its getting messy, are there better ways to manage this?

The problem in detail:

#. There is a class A with virtual foo1 and foo2
#. There are 'lots' of derived classes of A which implement foo1 and foo2
#. Executable1 needs to use both foo1 and foo2
#. Executable2 only needs to use foo1, never needs foo2

How to make sure that all the foo2 code never gets into executable2? Lots of
#ifdefs can be used for this but is there a better solution? Maybe some
clever use of templates? Something else less complicated?

Instead of preventing the code from being in both executables it might
be easier to just prevent foo2 from being called, perhaps by using
#ifdefs to select which kinds of input the program accepts.

--
Erik Wikström

[Sachin Garg]

<sh*******@mail.ruwrote in message
news:8f**********************************@s50g2000 hsb.googlegroups.com...

On Jun 7, 1:37 am, "Sachin Garg" <[e-mail]:

>I need to build two executables from my code, one having all the code
(and
thus application features) and other not having it all. How to best
manage
the code that shouldn't go in one of the executables?

My first thought is to use conditional compilation with #define and
#ifdef
etc but its getting messy, are there better ways to manage this?

The problem in detail:

#. There is a class A with virtual foo1 and foo2
#. There are 'lots' of derived classes of A which implement foo1 and foo2
#. Executable1 needs to use both foo1 and foo2
#. Executable2 only needs to use foo1, never needs foo2

How to make sure that all the foo2 code never gets into executable2? Lots
of
#ifdefs can be used for this but is there a better solution? Maybe some
clever use of templates? Something else less complicated?

Thanks

Hm, don't know if that's what you want, but here's how it can be done:

template <bool Use>
class foo2
{
//implementation in case of it's not needed
}

template <>
class foo2<true>
{
//implementation in case of it's needed
}

template <bool Use>
class foo2derived : public foo2<Use>
{
//implementation in case of it's not needed
}

template <>
class foo2derived : public foo2<true>
{
//implementation in case of it's needed
}

Usage:

const bool UseFoo2 = ...;

foo2derived<UseFoo2f2d; //will compile the needed version of
foo2derived

Thanks, this helps.

[Sachin Garg]

"Erik Wikström" <Er***********@telia.comwrote in message
news:YW*****************@newsb.telia.net...

On 2008-06-06 23:37, Sachin Garg wrote:

>I need to build two executables from my code, one having all the code
(and
thus application features) and other not having it all. How to best
manage
the code that shouldn't go in one of the executables?

My first thought is to use conditional compilation with #define and
#ifdef
etc but its getting messy, are there better ways to manage this?

The problem in detail:

#. There is a class A with virtual foo1 and foo2
#. There are 'lots' of derived classes of A which implement foo1 and foo2
#. Executable1 needs to use both foo1 and foo2
#. Executable2 only needs to use foo1, never needs foo2

How to make sure that all the foo2 code never gets into executable2? Lots
of
#ifdefs can be used for this but is there a better solution? Maybe some
clever use of templates? Something else less complicated?

Instead of preventing the code from being in both executables it might
be easier to just prevent foo2 from being called, perhaps by using
#ifdefs to select which kinds of input the program accepts.

I have done this, wanted to also prevent unused code from getting in the
exe.

[James Kanze]

On Jun 6, 11:37 pm, "Sachin Garg" <[e-mail]:

I need to build two executables from my code, one having all
the code (and thus application features) and other not having
it all. How to best manage the code that shouldn't go in one
of the executables?

My first thought is to use conditional compilation with
#define and #ifdef etc but its getting messy, are there better
ways to manage this?

The problem in detail:

#. There is a class A with virtual foo1 and foo2
#. There are 'lots' of derived classes of A which implement foo1 and foo2
#. Executable1 needs to use both foo1 and foo2
#. Executable2 only needs to use foo1, never needs foo2

How to make sure that all the foo2 code never gets into
executable2? Lots of #ifdefs can be used for this but is there
a better solution? Maybe some clever use of templates?
Something else less complicated?

Generally, if a class has two different interfaces, it's two
different classes. You'd have to be more concrete; the usual
solution for conditionally including functions and/or objects is
to put the conditional objects in separate source files, and
either link the corresponding object files in or not.

In your case, it looks to me like you have two separate
hierachies: one with just foo1, and one with both. This could
be done using multiple inheritance, something like:

class Base
{
public:
virtual void foo1() = 0 ;
} ;

class Derived : public virtual Base
{
public:
virtual void foo1() ;
} ;

and:

class BaseOptional : public virual Base
{
public:
virtual void foo2() = 0 ;
} ;

class DerivedOptional : public virtual Derived
{
public:
virtual void foo2() ;
} ;

Put the ...Optional in a separate directory and library.

Personally, however, I'd reconsider the design before I adopted
such complexity. Couldn't two separate hierarchies be made to
work as well, if not better?

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Sachin Garg]

"Sam" <sa*@email-scan.comwrote in message
news:co*****************************@commodore.ema il-scan.com...
Sachin Garg writes:

The problem in detail:

#. There is a class A with virtual foo1 and foo2
#. There are 'lots' of derived classes of A which implement foo1 and
foo2
#. Executable1 needs to use both foo1 and foo2
#. Executable2 only needs to use foo1, never needs foo2

How to make sure that all the foo2 code never gets into executable2?
Lots of
#ifdefs can be used for this but is there a better solution?

Yes: organizing your code.

Put all code derived from foo2 into separate translation units. Do not
include those translation units in your second executable.

Hmmm, worth a try.

ps. There is maybe something wrong with your news reader, your message came
in a 'text attachment', while the actual post was empty (atleast thats how
it came in outlook express). You might want to check this out.

[Sam]

Sachin Garg writes:

>
Hmmm, worth a try.

ps. There is maybe something wrong with your news reader, your message came
in a 'text attachment', while the actual post was empty (atleast thats how
it came in outlook express). You might want to check this out.

There's nothing wrong with my newsreader. This is a well known bug in your
Outlook Express, which still fails to implement a thirteen-year old standard
for digitally-signed messages.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (GNU/Linux)

iEYEABECAAYFAkhKphEACgkQx9p3GYHlUOIEbwCfcWz1HK7zHk LcXyY5MEm3UP7w
r0wAn2B628rczMKT5MBvY51IhE3UFGBL
=MTHu
-----END PGP SIGNATURE-----

[Sachin Garg]

"Sam" <sa*@email-scan.comwrote in message
news:co******************************@commodore.em ail-scan.com...

Sachin Garg writes:

Hmmm, worth a try.

ps. There is maybe something wrong with your news reader, your message
came
in a 'text attachment', while the actual post was empty (atleast thats
how
it came in outlook express). You might want to check this out.

There's nothing wrong with my newsreader. This is a well known bug in your
Outlook Express, which still fails to implement a thirteen-year old
standard
for digitally-signed messages.

ok

[Sachin Garg]

"James Kanze" <ja*********@gmail.comwrote in message
news:d1**********************************@j22g2000 hsf.googlegroups.com...

On Jun 6, 11:37 pm, "Sachin Garg" <[e-mail]:

I need to build two executables from my code, one having all
the code (and thus application features) and other not having
it all. How to best manage the code that shouldn't go in one
of the executables?

My first thought is to use conditional compilation with
#define and #ifdef etc but its getting messy, are there better
ways to manage this?

The problem in detail:

#. There is a class A with virtual foo1 and foo2
#. There are 'lots' of derived classes of A which implement foo1 and
foo2
#. Executable1 needs to use both foo1 and foo2
#. Executable2 only needs to use foo1, never needs foo2

How to make sure that all the foo2 code never gets into
executable2? Lots of #ifdefs can be used for this but is there
a better solution? Maybe some clever use of templates?
Something else less complicated?

Generally, if a class has two different interfaces, it's two
different classes. You'd have to be more concrete; the usual
solution for conditionally including functions and/or objects is
to put the conditional objects in separate source files, and
either link the corresponding object files in or not.

In your case, it looks to me like you have two separate
hierachies: one with just foo1, and one with both. This could
be done using multiple inheritance, something like:

[code snipped]

Put the ...Optional in a separate directory and library.

Personally, however, I'd reconsider the design before I adopted
such complexity. Couldn't two separate hierarchies be made to
work as well, if not better?

Duh, I was

Back to the drawing board :-)

[Sachin Garg]

"Sachin Garg" <sa********@c10n.infowrote in message
news:g2**********@aioe.org...

>
"James Kanze" <ja*********@gmail.comwrote in message
news:d1**********************************@j22g2000 hsf.googlegroups.com...

>On Jun 6, 11:37 pm, "Sachin Garg" <[e-mail]:

I need to build two executables from my code, one having all
the code (and thus application features) and other not having
it all. How to best manage the code that shouldn't go in one
of the executables?

My first thought is to use conditional compilation with
#define and #ifdef etc but its getting messy, are there better
ways to manage this?

The problem in detail:

#. There is a class A with virtual foo1 and foo2
#. There are 'lots' of derived classes of A which implement foo1 and
foo2
#. Executable1 needs to use both foo1 and foo2
#. Executable2 only needs to use foo1, never needs foo2

How to make sure that all the foo2 code never gets into
executable2? Lots of #ifdefs can be used for this but is there
a better solution? Maybe some clever use of templates?
Something else less complicated?

Generally, if a class has two different interfaces, it's two
different classes. You'd have to be more concrete; the usual
solution for conditionally including functions and/or objects is
to put the conditional objects in separate source files, and
either link the corresponding object files in or not.

In your case, it looks to me like you have two separate
hierachies: one with just foo1, and one with both. This could
be done using multiple inheritance, something like:

[code snipped]

Put the ...Optional in a separate directory and library.

Personally, however, I'd reconsider the design before I adopted
such complexity. Couldn't two separate hierarchies be made to
work as well, if not better?

Duh, I was

Back to the drawing board :-)

Hit 'send' a bit too soon :-p

I was probably trying to use this conditional compilation on top of existing
design to patch up for this new requirement. You are right that a fresh
rethink on the design can give more elegant solutions.

Back to the drawing board :-)

Thanks.