Can I implement Factory-pattern construction without using new()?

Question

At the moment I'm dealing with a delightful legacy code class implementing polymorphism by switch-case:

class LegacyClass {
 public:
    enum InitType {TYPE_A, TYPE_B};
    void init(InitType type) {m_type=type;}

    int foo() {
        if (m_type==TYPE_A) 
        { 
            /* ...A-specific work... */
            return 1;
        }
        // else, TYPE_B:
        /* ...B-specific work... */
        return 2;
    }

    /** Lots more functions like this **/

  private:
    InitType m_type;
 };

I'd like to refactor this to proper polymorphism, e.g.:

class RefactoredClass {
 public:
    virtual ~RefactoredClass(){}
    virtual int foo()=0;
 };

 class Class_ImplA : public RefactoredClass {
 public:
    virtual ~Class_ImplA(){}
    int foo() {
        /* ...A-specific work... */
        return 1;
    }
 };

class Class_ImplB : public RefactoredClass {
 public:
    virtual ~Class_ImplB(){}
    int foo() {
        /* ...B-specific work... */
        return 2;
    }
 };

Unfortunately, I have one crucial problem: due to optimization and architectural considerations, within a primary use of LegacyClass, I cannot use dynamic allocation; the instance is a member of a different class by composition:

 class BigImportantClass{
    /* ... */
  private:
    LegacyClass m_legacy;
 }

(In this example, BigImportantClass may be dynamically allocated, but the allocation needs to be in one continuous virtual segment, and a single new() call; I can't make further calls to new() in the BigImportantClass ctor or in subsequent initialization methods.)

Is there a good way to initialize a concrete implementation, polymorphically, without using new()?

My own progress so far: What I can do is provide a char[] buffer as a member of BigImportantClass, and somehow initialize a concrete member of RefactoredClass in that memory. The buffer would be large enough to accommodate all implementations of RefactoredClass. However, I do not know how to do this safely. I know the placement-new syntax, but I'm new to dealing with alignment (hence, warned off by the C++-FAQ...), and aligning generically for all concrete implementations of the RefactoredClass interface sounds daunting. Is this the way to go? Or do I have any other options?

You could keep the polymorphic hierarchy private to some ambient class and only use dynamic allocation internally. — Kerrek SB
– Kerrek SB, Commented Mar 12, 2014 at 22:16
If you know which implementation you need before the BigImportantClass constructor, you might be able to use a template. — wimh
– wimh, Commented Mar 12, 2014 at 22:17
@Wimmel : I'm considering a template - that'd be quick! - but that means dragging the implementation choice up to a much more visible level (BigImportantClass becomes BigImportantClass<TYPE_A>). It's definitely an option, though. — Ziv
– Ziv, Commented Mar 12, 2014 at 22:19
@Ziv You can hide the implementation choice in a factory function, like CreateBigImportantClass(), which can even be a static member. — wimh
– wimh, Commented Mar 12, 2014 at 22:23
You do realise this any virtual dispatch to small functions likely be significantly slower than the Legacy switch? Anyway, don't put a char[] in BigImportantClass, replace LegacyClass with a class than embeds an aligned buffer. You can probably get away using a union of a double and char[] - hardly anything needs more alignment than double. The Replacement class should have a function to get a reference or pointer to the placement-newed object. — Tony Delroy
– Tony Delroy, Commented Mar 12, 2014 at 22:29

Tony Delroy · Accepted Answer · 2014-03-13 15:37:26Z

Here's some code... just doing the obvious things. I don't use C++11's new union features, which might actually be a more structured way to ensure appropriate alignment and size and clean up the code.

#include <iostream>

template <size_t A, size_t B>
struct max
{
    static const size_t value = A > B ? A : B;
};

class X
{
  public:
    X(char x) { construct(x); }

    X(const X& rhs)
        { rhs.interface().copy_construct_at_address(this); }

    ~X() { interface().~Interface(); }

    X& operator=(const X& rhs)
    {
        // warning - not exception safe
        interface().~Interface();
        rhs.interface().copy_construct_at_address(this);
        return *this;
    }

    struct Interface
    {
        virtual ~Interface() { }
        virtual void f(int) = 0;
        virtual void copy_construct_at_address(void*) const = 0;
    };

    Interface& interface()
        { return reinterpret_cast<Interface&>(data_); }

    const Interface& interface() const
        { return reinterpret_cast<const Interface&>(data_); }

    // for convenience use of virtual members...
    void f(int x) { interface().f(x); }

  private:
    void construct(char x)
    {
             if (x == 'A') new (data_) Impl_A();
        else if (x == 'B') new (data_) Impl_B();
    }

    struct Impl_A : Interface
    {
        Impl_A() : n_(10) { std::cout << "Impl_A(this " << this << ")\n"; }
        ~Impl_A() { std::cout << "~Impl_A(this " << this << ")\n"; }
        void f(int x)
            { std::cout << "Impl_A::f(x " << x << ") n_ " << n_;
              n_ += x / 3;
              std::cout << " -> " << n_ << '\n'; }
        void copy_construct_at_address(void* p) const { new (p) Impl_A(*this); }
        int n_;
    };

    struct Impl_B : Interface
    {
        Impl_B() : n_(20) { std::cout << "Impl_B(this " << this << ")\n"; }
        ~Impl_B() { std::cout << "~Impl_B(this " << this << ")\n"; }
        void f(int x)
            { std::cout << "Impl_B::f(x " << x << ") n_ " << n_;
              n_ += x / 3.0;
              std::cout << " -> " << n_ << '\n'; }
        void copy_construct_at_address(void* p) const { new (p) Impl_B(*this); }
        double n_;
    };

    union
    {
        double align_;
        char data_[max<sizeof Impl_A, sizeof Impl_B>::value];
    };
};

int main()
{
    {
        X a('A');
        a.f(5);

        X b('B');
        b.f(5);
        X x2(b);
        x2.f(6);
        x2 = a;
        x2.f(7);
    }
}

Output (with my comments):

Impl_A(this 0018FF24)
Impl_A::f(x 5) n_ 10 -> 11
Impl_B(this 0018FF04)
Impl_B::f(x 5) n_ 20 -> 21.6667
Impl_B::f(x 6) n_ 21.6667 -> 23.6667
~Impl_B(this 0018FF14)           // x2 = a morphs type
Impl_A::f(x 7) n_ 11 -> 13       // x2 value 11 copied per a's above
~Impl_A(this 0018FF14)
~Impl_B(this 0018FF04)
~Impl_A(this 0018FF24)

QuestionC · Accepted Answer · 2014-03-13 16:30:31Z

2

I implemented this using C++11 unions. This code seems to work under g++ 4.8.2, but it requires the -std=gnu++11 or -std=c++11 flags.

#include <iostream>

class RefactoredClass {
  public:
  virtual ~RefactoredClass() { }; // Linking error if this is pure.  Why?
  virtual int foo() = 0;
};

class RefactorA : RefactoredClass {
  double data1, data2, data3, data4;

  public:
  int foo() { return 1; }
  ~RefactorA() { std::cout << "Destroying RefactorA" << std::endl; }
};

class RefactorB : RefactoredClass {
  int data;

  public:
  int foo () { return 2; }
  ~RefactorB() { std::cout << "Destroying RefactorB" << std::endl; }
};

// You may need to manually create copy, move, &ct operators for this.
// Requires C++11
union LegacyClass {
  RefactorA refA;
  RefactorB refB;

  LegacyClass(char type) { 
    switch (type) {
      case 'A':
        new(this) RefactorA;
        break;
      case 'B':
        new(this) RefactorB;
        break;
      default:
        // Rut-row
        break;
    }
  }

  RefactoredClass * AsRefactoredClass() { return (RefactoredClass *)this; }

  int foo() { return AsRefactoredClass()->foo(); }

  ~LegacyClass() { AsRefactoredClass()->~RefactoredClass(); }

};

int main (void) {
  LegacyClass A('A');
  LegacyClass B('B');

  std::cout << A.foo() << std::endl;
  std::cout << B.foo() << std::endl;

  return 0;
}

answered Mar 13, 2014 at 16:30

QuestionC

10.1k4 gold badges28 silver badges44 bronze badges

1 Comment

Tony Delroy Over a year ago

+1 - not bad ;-). "Linking error if this is pure. Why?" - as objects are destroyed, the destructors run from most-derived back to base... destroying any data members, setting the pointer to the virtual dispatch table back too so overrides from already destroyed levels of derived class aren't used....

Zan Lynx · Accepted Answer · 2014-03-12 23:23:21Z

0

Somebody should have made an answer by now...so here's mine.

I'd recommend using a union of char array and one of the biggest integer types:

union {
    char refactored_class_buffer[ sizeof RefactoredClass ];
    long long refactored_class_buffer_aligner;
};

I also strongly recommend putting an assert or even an if(check) throw; into your factory so that you never, ever, exceed the size of your buffer.

answered Mar 12, 2014 at 23:23

Zan Lynx

54.7k11 gold badges85 silver badges135 bronze badges

Comments

Michael Anderson · Accepted Answer · 2014-03-13 00:19:55Z

If the data is the same for each case, and you're only changing behaviuor, you don't need to allocate in your core - this is basically a strategy pattern using singleton strategies. You end up using polymorphism in your logic, but not in your data.

class FooStrategy() {
virtual int foo(RefactoredClass& v)=0;
}

class RefactoredClass {
   int foo() {
     return this.fooStrategy(*this);
   }
   FooStrategy * fooStrategy;
};

class FooStrategyA : public FooStrategy {

   //Use whichever singleton pattern you're happy with.
   static FooStrategyA* instance() {
      static FooStrategyA fooStrategy;
      return &fooStrategy;
   }

   int foo(RefactoredClass& v) {
      //Do something with v's data
   }
}

//Same for FooStrategyB

Then when you create a RefactoredClass you set its fooStrategy to FooStrategyA::instance().

Collectives™ on Stack Overflow

Can I implement Factory-pattern construction without using new()?

4 Answers 4

Comments

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related