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

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-----

On Jun 7, 1:37 am, "Sachin Garg" <saching...@c10n.info> 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?
>
> 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<UseFoo2> f2d; //will compile the needed version of
foo2derived

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

<sheffmail@mail.ru> wrote in message
news:8ff98162-411b-4661-8d42-57c73c38bda8@s50g2000hsb.googlegroups.com...
> On Jun 7, 1:37 am, "Sachin Garg" <saching...@c10n.info> 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?
>>
>> 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<UseFoo2> f2d; //will compile the needed version of
> foo2derived

Thanks, this s.

"Erik Wikström" <Erik-wikstrom@telia.com> wrote in message
news:YWi2k.8131$R_4.6443@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.

On Jun 6, 11:37 pm, "Sachin Garg" <saching...@c10n.info> 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?

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:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

"Sam" <sam@email-scan.com> wrote in message
news:cone.1212790398.95875.13685.500@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.