Thread: factory pattern using static

Can anyone tell me why factory pattern depend on static ? is it because static inheritance allows objects to be instantiated or static member data can be shared across all instances or static member function doesn't need to be called from an instance of their own class or static data at function scope persists between function calls here?

Code:

class  Vehcle{ 
public: 
    virtual void displayVehcle() = 0; 
    static Vehicle* Create(VehcleType type); 
}; 
class TwoWheeler : public Vehcle { 
public: 
    void printVehcle() { 
        cout << "two wheeler" << endl; 
    } 
}; 
class ThreeWheeler : public Vehcle { 
public: 
    void printVehcle() { 
        cout << "three wheeler" << endl; 
    } 
}; 
class FourWheeler : public Vehcle { 
    public: 
    void printVehcle() { 
        cout << "four wheeler" << endl; 
    } 
}; 
  
Vehcle* Vehcle::Create(VehcleType type) { 
    if (type == VT_TwoWheeler) 
        return new TwoWheeler(); 
    else if (type == VT_ThreeWheeler) 
        return new ThreeWheeler(); 
    else if (type == VT_FourWheeler) 
        return new FourWheeler(); 
    else return NULL; 
}

Did you mean to say that is it because static inheritance allows objects to be instantiated or static member data can be shared across all instances or static member function doesn't need to be called from an instance of their own class or static data at function scope persists between function calls here?

This is not MCQ, I suspected those could be the reasons. My strong suspect is that static member function doesn't need to be called from an instance of their own class . i am not a design pattern expert.

Correct.

A factory method is a method that is called to build an instance of a class (or subclass). For this reason, you don't usually call factory methods using a class instance. Rather, you make the factory method a static method and call against the class directly.

Code:

new_instance = instance.factory(args);   // NO!

new_instance = Class::factory(args);    // YES!

Originally Posted by aghast

Correct.

A factory method is a method that is called to build an instance of a class (or subclass). For this reason, you don't usually call factory methods using a class instance. Rather, you make the factory method a static method and call against the class directly.

Code:

new_instance = instance.factory(args);   // NO!

new_instance = Class::factory(args);    // YES!

To be fair, you could have a factory that creates objects from an instance. Suppose you want to create objects with the same complex set of arguments; you could have an instance that contains the arguments, and then you just have to ask that instance to create a new object for those arguments. For example:

Code:

MyFactory* f = new MyFactory();
// set a bunch of arguments
f
  .setFoo(foo)
  .setBar(bar)
  .setBuzz(buzz);

MyObject* obj = f.newObject();