Subclass specific access in Factory pattern

Question

I have a design based question where I want to avoid dynamic_cast but still want to know how to get to loose coupling.

 class Prod { // Prod has lot of subclasses 
 public:    
      void method()
      {//Some Implementation
      } 
 };

 class Prod_X : Prod 
 { 
     int special_variable; 
     public:    
         void method()
            {//Override Base
            }    
         void setSpecialVariable() 
            {//Set Special Variable
            } 
 };

 class Factory 
 { 
 public: 
      Prod* create(string &s) 
      { if (s == "X") return new Prod_X; //And so on
      };
 };

  class O 
  { 
  public: 
       Factory F; // Assume we are talking about a simple factory pattern 
       Prod* create(string &s) 
       { p = F.create(s); return p;}
       Prod* p; 
  };


 // Issue is here on coupling and how to avoid dynamic_cast
 // Inherited Prod member for O_derived_X is always Prod_X (Factory takes care of that) 
 class O_derived_X { 
 int special_variable; 
 public: 
      void setSpecialVariable() 
      { // Need to set Prod_X Variable 
        Prod_X *px = dynamic_cast<Prod_X*>(p); 
        px->setSpecialVariable(); 
      } 
 };

Two things

I introduced the special_variable in Prod_X because it was an attribute of Prod_X and not Prod in general. Is this right?
class O basically uses the interface of class Prod to do mostly everything. But, for this special variable, O_derived_X is interested in setting it correctly.

Could you suggest where I am going wrong? Or how can I refactor the code?

There is no need in `dynamic_cast`, you can just use `static_cast`. — , Jul 28 '11 at 12:55
But isn't static_cast (also dynamic_cast) going to result in an undefined behaviour {See [link] (http://stackoverflow.com/questions/6322949/downcasting-using-the-static-cast-in-c)} — jmishra, Jul 28 '11 at 13:01
No UB, because you know what the dynamic type of 'p' is. And since you know for sure, there is no need to dynamic_cast. static_cast is your friend here. — rodrigo, Jul 28 '11 at 13:08
at some point you need a way to make the difference between Prod and Prod_X; whether it's a cast, or another create() method that yields a specific product, but you need something. are you familiar with COM? there you have interfaces, coclasses that implement the interfaces and class objects or factories, that know how to create the coclass instances. but then you also have this `QueryInterface` method that allows you to get a pointer to another interface the object implements. how it does that? casting... — Marius Bancila, Jul 28 '11 at 13:17

score 1 · Accepted Answer · answered Jul 28 '11 at 14:29

In an ideal design, publicly inherited classes have an "is a" relation and not an "is an extension of" relation in the sense that they may be extended but you don't notice it from the interface point of view. This is best achieved if you actually order objects to do something and you don't get/set them. In that case factories can just create what is needed and clients don't need to know the actual class (polymorphism).

This is not always possible/easy, so casting could be the solution, but you could argue that a factory may not be needed in that case (O_derived_X could create a Prod_X object itself).

Subclass specific access in Factory pattern

1 Answers1