Re: inheritance headache....

b...@blah.com wrote:


you not need "else" after "return"


Not sure about "actually EVERYWHERE", but the job is well-known design
pattern called as Abstract Factory.

The Factory returns concrete set of objects and knowledge about
correct type of returned objects is responsibility of the Factory,
encapsulated by the Factory, why "actually EVERYWHERE"?

Abstract Factory often used as link-time compatible part of program,
so implementation of the Factory is often runtime template (looks like
trivial case of well-known design pattern called as Template Method) -
removing implementation of interface of abstract base class into
derived classes.

Abstract Factory declare interface of creators:

class Abstract_Factory
{
public:

  virtual
  abstractTarget*
  Abstract_Factory::createTarget
   (abstractDescription* desc)
   =0;
};

Concrete Factory, derived from Abstract Factory, encapsulates concrete
set of returned objects:

namespace N1feb2008{
class Concrete_Factory: public Abstract_Factory
{
public:
  abstractTarget*
  concrete_Factory::createTarget
   (abstractDescription* desc)
 {
    if ( desc is concreteDesc1)
      return new concreteTarget1;

    if (desc is concreteDesc2)
      return new concreteTarget2;

    return 0;
 }
};}

namespace N2feb2008{
template
 <
 class Told_Factory=N1feb2008::Concrete_Factory
 >
class Concrete_Factory: public Abstract_Factory
{
Told_Factory old;

public:
  abstractTarget*
  concrete_Factory::createTarget
   (abstractDescription* desc)
 {
    if ( desc is concreteDesc3)
      return new concreteTarget3;

    return old.createTarget(desc);
 }
};}


Not sure what does it mean "cannot be modified in any way". There is
well-known design pattern Adapter, that can adapt in fact everything
to everywhere.

In the case, Adapter will add to abstractDescription new method for
new "create" message of new requested interface (class
Adapted_Description).

//compile time template
namespace Nctt
{
//types
//they encapsulate links
//between Target and Description

template<class Tadapted>
struct Tlink;

//
template<>struct
Tlink<concreteDescription1>
{ typedef concreteTarget1 Target; };

//
template<>struct
Tlink<concreteDescription2>
{ typedef concreteTarget2 Target; };

//
template<>struct
Tlink<concreteDescription3>
{ typedef concreteTarget3 Target; };

//end of types

//adapter
template<class Tadapted, class Towner=Tadapted>
class Adapted_Description: public abstractDescription
{
public:
  typedef
   typename Tlink<Tadapted>::Target
   Target;

protected:
  Towner adapted;

//new interface
public:
  Target* create()
  { return new Target; }

  Adapted_Description();
  Adapted_Description(const Towner& ad):
   adapted(ad);

//old interface
public:

for each
  abstractDescription::method
   { adapted.abstractDescription::method; }

};

//namespace Nctt
}

//run time template
namespace Nrtt
{

class Adapted_Description: public abstractDescription
{
//new interface
public:
   virtual
   AbstractTarget*
   create()
    =0;
};

template<class Tadapted, class Towner=Tadapted>
class concrete_Description: public Adapted_Description
{
public:
  typedef
   typename Nctt::Adapted_Description
    <Tadapted, Towner>
   Nctt_Adapted_Description;

  typedef
   typename
    Nctt_Adapted_Description::Target
    Target;

protected:
   Nctt_Adapted_Description
    adapted;

//Ncct::Adapted_Description interface

for each
  Nctt_Adapted_Description ctor
   { concrete_Description():adapted(); }
  /*
  concrete_Description()
   adapted();
  concrete_Description(const Towner& ad):
   adapted(ad);
  */

/*
//new interface (part of Adapted_Description interface)
public:
   Target*
   create()
    { return adapted.create(); }
*/

//old interface
public:

for each
  Adapted_Description::method
   { adapted.Ncct_Adapted_Description::method; }

};

//namespace Nrtt
}

This can be compiled

void foo()
{
Nctt::Adapted_Description
<concreteDescription1>
 tmp;

Nrtt::concrete_Description
<concreteDescription1>
 tmp2;

 tmp.create();
 tmp2.create();
}

declare and define all

class abstractDescription{};
class AbstractTarget{};

class concreteDescription1:
 public abstractDescription {};
class concreteDescription2:
 public abstractDescription {};
class concreteDescription3:
 public abstractDescription {};

class concreteTarget1:
 public AbstractTarget {};
class concreteTarget2:
 public AbstractTarget {};
class concreteTarget3:
 public AbstractTarget {};

and comment "for each" sections and not-defined ctors

Maksim A. Polyanin
http://grizlyk1.narod.ru/cpp_new