[c++] C ++에서 factory 메소드 패턴을 올바르게 구현하는 방법



4 Answers

간단한 공장 예 :

// Factory returns object and ownership
// Caller responsible for deletion.
#include <memory>
class FactoryReleaseOwnership{
  public:
    std::unique_ptr<Foo> createFooInSomeWay(){
      return std::unique_ptr<Foo>(new Foo(some, args));
    }
};

// Factory retains object ownership
// Thus returning a reference.
#include <boost/ptr_container/ptr_vector.hpp>
class FactoryRetainOwnership{
  boost::ptr_vector<Foo>  myFoo;
  public:
    Foo& createFooInSomeWay(){
      // Must take care that factory last longer than all references.
      // Could make myFoo static so it last as long as the application.
      myFoo.push_back(new Foo(some, args));
      return myFoo.back();
    }
};
Question

C ++에는 꽤 오랜 시간 동안 불편 함을 느끼게합니다. 왜냐하면 솔직히 말해서 나는 그것을 어떻게 할 지 모르기 때문입니다.

C ++에서 Factory Method를 올바르게 구현하려면 어떻게해야합니까?

목표 : 클라이언트가 허용되지 않는 결과와 성능 저하없이 객체의 생성자 대신에 팩토리 메소드를 사용하여 일부 객체를 인스턴스화 할 수 있도록 허용합니다.

"팩토리 메서드 패턴"이란, 개체 내부의 정적 팩터 리 메서드 또는 다른 클래스에 정의 된 메서드 또는 전역 함수를 의미합니다. 일반적으로 "클래스 X 인스턴스화의 일반적인 방법을 생성자가 아닌 다른 곳으로 리디렉션하는 개념"입니다.

내가 생각한 몇 가지 가능한 답을 훑어 보자.

0) 공장을 만들지 말고, 생성자를 만드십시오.

좋은 (실제로는 가장 좋은 해결책) 소리가 들리지만 일반적인 치료법은 아닙니다. 우선, 객체 생성이 다른 클래스로의 추출을 정당화하기에 충분히 복잡한 작업 인 경우가 있습니다. 그러나 심지어는 사실을 제쳐 놓고, 단지 생성자를 사용하는 단순한 객체의 경우조차도 그렇게하지 않을 수 있습니다.

제가 아는 가장 간단한 예제는 2-D Vector 클래스입니다. 그렇게 간단하면서도 까다 롭습니다. 나는 직교 좌표와 극좌표 모두에서 그것을 만들 수 있기를 원한다. 분명히, 나는 할 수 없다 :

struct Vec2 {
    Vec2(float x, float y);
    Vec2(float angle, float magnitude); // not a valid overload!
    // ...
};

내 사고 방식은 다음과 같습니다.

struct Vec2 {
    static Vec2 fromLinear(float x, float y);
    static Vec2 fromPolar(float angle, float magnitude);
    // ...
};

생성자 대신 정적 팩토리 메서드를 사용하게되는데, 필자는 기본적으로 어떤 식 으로든 (즉 클래스가 자체 공장이되는) 팩터 리 패턴을 구현한다는 것을 의미합니다. 이것은 멋지게 보이지만 (이 특별한 경우에 맞을 것입니다.), 어떤 경우에는 실패합니다. 2 번에서 설명 할 것입니다. 계속 읽어보십시오.

또 다른 경우 : 일부 API의 두 가지 불투명 한 typedef (관련이없는 도메인의 GUID 또는 GUID와 비트 필드와 같은)로 오버로드하려고 시도하고, 의미 상으로 완전히 다른 유형 (이론적으로 - 유효한 오버로드)을 입력하지만 실제적으로 같은 것 - 부호없는 int 나 void 포인터처럼.

1) 자바 방식

Java는 동적 할당 객체 만 가지고 있기 때문에 간단합니다. 공장 만들기는 다음과 같이 사소한 것입니다.

class FooFactory {
    public Foo createFooInSomeWay() {
        // can be a static method as well,
        //  if we don't need the factory to provide its own object semantics
        //  and just serve as a group of methods
        return new Foo(some, args);
    }
}

C ++에서 이것은 다음과 같이 번역됩니다.

class FooFactory {
public:
    Foo* createFooInSomeWay() {
        return new Foo(some, args);
    }
};

시원한? 실제로, 종종. 그러나 그런 다음에는 사용자가 동적 할당 만 사용해야합니다. 정적 할당은 C ++을 복잡하게 만드는 요인이지만, 종종 강력하게 만듭니다. 또한 동적 할당을 허용하지 않는 일부 대상 (키워드 : 포함)이 있다고 생각합니다. 그리고 이것은 그러한 플랫폼의 사용자가 깨끗한 OOP를 작성하는 것을 의미하지는 않습니다.

어쨌든, 철학은 제쳐두고 : 일반적인 경우, 나는 공장의 사용자들이 동적 인 할당에 묶이지 않도록하고 싶지 않다.

2) 가치에 의한 반환

좋습니다, 그래서 우리는 동적 할당을 원할 때 1) 멋지다는 것을 압니다. 정적 할당을 추가하지 않는 이유는 무엇입니까?

class FooFactory {
public:
    Foo* createFooInSomeWay() {
        return new Foo(some, args);
    }
    Foo createFooInSomeWay() {
        return Foo(some, args);
    }
};

뭐? 우리는 리턴 타입으로 오버로드 할 수 없습니까? 오 물론 우리는 할 수 없습니다. 메소드 이름을 변경하여이를 반영하도록합시다. 그리고 네, 메소드 이름을 바꿀 필요가 없다는 것을 얼마나 강조했는지를 강조하기 위해 위의 잘못된 코드 예제를 작성했습니다. 예를 들어 이름을 변경해야하므로 언어에 구애받지 않는 팩토리 디자인을 제대로 구현할 수 없기 때문입니다. 이 코드의 모든 사용자는 사양과 구현의 차이점을 기억해야합니다.

class FooFactory {
public:
    Foo* createDynamicFooInSomeWay() {
        return new Foo(some, args);
    }
    Foo createFooObjectInSomeWay() {
        return Foo(some, args);
    }
};

OK ... 우리는 그것을 가지고있다. 메서드 이름을 변경해야하기 때문에 추한 것입니다. 동일한 코드를 두 번 작성해야하기 때문에 불완전합니다. 그러나 일단 끝나면 작동합니다. 권리?

글쎄, 보통. 그러나 때때로 그렇지 않습니다. Foo를 만들 때, 우리는 실제로 컴파일러에 의존하여 반환 값 최적화를 수행합니다. 왜냐하면 C ++ 표준은 컴파일러 공급 업체가 언제 어디에서 객체를 만들지를 지정하지 않아도되고 객체를 반환 할 때 언제 복사 될지 지정하지 않기 때문에 C ++에서 값에 의한 임시 객체. 따라서 Foo가 복사하는 데 비용이 많이 든다면이 방법은 위험합니다.

Foo가 전혀 복사 할 수 없다면 어떨까요? 글쎄. ( copy elision이 보장 된 C ++ 17에서는 위의 코드에 대해 더 이상 복사 할 수 없다는 점에 유의하십시오 )

결론 : 객체를 반환하여 팩토리를 만드는 것은 실제로 몇몇 경우 (예 : 앞에서 언급 한 2-D 벡터)의 솔루션이지만, 여전히 생성자를 대체하는 것은 아닙니다.

3) 2 상 공사

다른 사람이 생각해내는 또 다른 사항은 객체 할당과 초기화의 문제를 분리하는 것입니다. 일반적으로 다음과 같은 코드가 생성됩니다.

class Foo {
public:
    Foo() {
        // empty or almost empty
    }
    // ...
};

class FooFactory {
public:
    void createFooInSomeWay(Foo& foo, some, args);
};

void clientCode() {
    Foo staticFoo;
    auto_ptr<Foo> dynamicFoo = new Foo();
    FooFactory factory;
    factory.createFooInSomeWay(&staticFoo);
    factory.createFooInSomeWay(&dynamicFoo.get());
    // ...
}

사람은 그것이 매력처럼 작동한다고 생각할 수도 있습니다. 코드에서 우리가 지불해야하는 유일한 가격은 ...

나는이 모든 것을 쓰고 이것을 마지막으로 남겨 두었으므로 나는 그것을 싫어해야합니다. :) 왜?

무엇보다도 ... 나는 진실로 2 단계 건설의 개념을 싫어하며, 내가 그것을 사용할 때 죄책감을 느낀다. "존재한다면 그것이 유효한 상태"라는 주장을 가지고 객체를 디자인하면 내 코드가 안전하고 오류가 발생하기 쉽지 않습니다. 그 방법이 마음에 들어요.

그 컨벤션을 버리고 공장을 만들기위한 목적으로 내 물건의 디자인을 변경하는 것은 .. 잘, 다루기 힘든 일입니다.

위의 내용이 많은 사람들을 납득시키지 않을 것이라는 것을 알고 있으므로 좀 더 확실한 주장을 해 둡니다. 2 단계 구성을 사용하면 다음 작업을 수행 할 수 없습니다.

  • const 또는 참조 멤버 변수 초기화,
  • 인수를 기본 클래스 생성자 및 멤버 객체 생성자에 전달합니다.

아마도 지금 당장 생각할 수없는 몇 가지 단점이있을 수 있습니다. 그리고 위의 글 머리 기호가 나에게 이미 설득력을 발휘 했으므로 특별히 고민하지 않아도됩니다.

그래서 : 공장을 구현하기위한 좋은 일반적인 해결책에 근접하지 않습니다.

결론 :

우리는 다음과 같은 객체 인스턴스화 방법을 원합니다.

  • 할당에 관계없이 균일 한 인스턴스 생성을 허용하고,
  • 건설 방법에 다른 의미있는 이름을 붙이십시오 (따라서 인수에 의한 과부하에 의존하지 마십시오).
  • 특히 클라이언트 측에서는 중요한 성능 히트를 유발하지 않으며, 중요한 코드가 부풀어 오르는 것이 바람직합니다.
  • 다음과 같이 일반적인 것 : 어떤 수업에도 소개 될 수 있습니다.

내가 언급 한 방법이 그 요구 사항을 충족시키지 못한다는 것을 증명했다고 나는 믿는다.

어떤 힌트? 제게 해결책을 제공해주세요. 저는이 언어가 제게 사소한 개념을 제대로 구현하지 못하리라고 생각하고 싶지 않습니다.




나는 대부분 받아 들인 대답에 동의하지만, 기존 답변에서 다루지 않은 C ++ 11 옵션이 있습니다 :

  • 값으로 팩터 리 메소드 결과 반환합니다.
  • 값싼 이동 생성자를 제공하십시오.

예:

struct sandwich {
  // Factory methods.
  static sandwich ham();
  static sandwich spam();
  // Move constructor.
  sandwich(sandwich &&);
  // etc.
};

그런 다음 스택에 객체를 만들 수 있습니다.

sandwich mine{sandwich::ham()};

다른 것들의 하위 객체로서 :

auto lunch = std::make_pair(sandwich::spam(), apple{});

또는 동적 할당 :

auto ptr = std::make_shared<sandwich>(sandwich::ham());

언제 이것을 사용할 수 있습니까?

public 생성자에서 예비 계산없이 모든 클래스 멤버에게 의미있는 초기화 프로그램을 제공 할 수없는 경우 해당 생성자를 정적 메서드로 변환 할 수 있습니다. 정적 메서드는 예비 계산을 수행 한 다음 멤버 별 초기화 만 수행하는 개인 생성자를 통해 값 결과를 반환합니다.

어떤 접근 방식이 불필요하게 비효율적이지 않으면 서 가장 명확한 코드를 제공하는지에 따라 달라질 수 있으므로 ' '이라고 말합니다.




공장 패턴

class Point
{
public:
  static Point Cartesian(double x, double y);
private:
};

그리고 만약 컴파일러가 리턴 값 최적화를 지원하지 않는다면, 아마 많은 최적화를 포함하지 않을 것입니다 ...




이것은 내 C ++ 11 스타일 솔루션입니다. 매개 변수 'base'는 모든 하위 클래스의 기본 클래스를 나타냅니다. 작성자, std :: function objects는 하위 클래스 인스턴스를 생성하기 위해 하위 클래스의 정적 멤버 함수 'create (some args)'에 대한 바인딩 일 수 있습니다. 이것은 완벽하지는 않지만 나를 위해 일합니다. 그리고 그것은 다소 '일반적인'해결책입니다.

template <class base, class... params> class factory {
public:
  factory() {}
  factory(const factory &) = delete;
  factory &operator=(const factory &) = delete;

  auto create(const std::string name, params... args) {
    auto key = your_hash_func(name.c_str(), name.size());
    return std::move(create(key, args...));
  }

  auto create(key_t key, params... args) {
    std::unique_ptr<base> obj{creators_[key](args...)};
    return obj;
  }

  void register_creator(const std::string name,
                        std::function<base *(params...)> &&creator) {
    auto key = your_hash_func(name.c_str(), name.size());
    creators_[key] = std::move(creator);
  }

protected:
  std::unordered_map<key_t, std::function<base *(params...)>> creators_;
};

사용법의 예.

class base {
public:
  base(int val) : val_(val) {}

  virtual ~base() { std::cout << "base destroyed\n"; }

protected:
  int val_ = 0;
};

class foo : public base {
public:
  foo(int val) : base(val) { std::cout << "foo " << val << " \n"; }

  static foo *create(int val) { return new foo(val); }

  virtual ~foo() { std::cout << "foo destroyed\n"; }
};

class bar : public base {
public:
  bar(int val) : base(val) { std::cout << "bar " << val << "\n"; }

  static bar *create(int val) { return new bar(val); }

  virtual ~bar() { std::cout << "bar destroyed\n"; }
};

int main() {
  common::factory<base, int> factory;

  auto foo_creator = std::bind(&foo::create, std::placeholders::_1);
  auto bar_creator = std::bind(&bar::create, std::placeholders::_1);

  factory.register_creator("foo", foo_creator);
  factory.register_creator("bar", bar_creator);

  {
    auto foo_obj = std::move(factory.create("foo", 80));
    foo_obj.reset();
  }

  {
    auto bar_obj = std::move(factory.create("bar", 90));
    bar_obj.reset();
  }
}



당신은 아주 좋은 해결책을 읽을 수 있습니다 : http://www.codeproject.com/Articles/363338/Factory-Pattern-in-Cplusplus

가장 좋은 해결책은 "의견 및 토론"에 있습니다. "정적 만들기 방법 필요 없음"을 참조하십시오.

이 아이디어에서 저는 공장을했습니다. Qt를 사용하고 있지만 QMap과 QString을 std에 상응하는 것으로 변경할 수 있습니다.

#ifndef FACTORY_H
#define FACTORY_H

#include <QMap>
#include <QString>

template <typename T>
class Factory
{
public:
    template <typename TDerived>
    void registerType(QString name)
    {
        static_assert(std::is_base_of<T, TDerived>::value, "Factory::registerType doesn't accept this type because doesn't derive from base class");
        _createFuncs[name] = &createFunc<TDerived>;
    }

    T* create(QString name) {
        typename QMap<QString,PCreateFunc>::const_iterator it = _createFuncs.find(name);
        if (it != _createFuncs.end()) {
            return it.value()();
        }
        return nullptr;
    }

private:
    template <typename TDerived>
    static T* createFunc()
    {
        return new TDerived();
    }

    typedef T* (*PCreateFunc)();
    QMap<QString,PCreateFunc> _createFuncs;
};

#endif // FACTORY_H

샘플 사용법 :

Factory<BaseClass> f;
f.registerType<Descendant1>("Descendant1");
f.registerType<Descendant2>("Descendant2");
Descendant1* d1 = static_cast<Descendant1*>(f.create("Descendant1"));
Descendant2* d2 = static_cast<Descendant2*>(f.create("Descendant2"));
BaseClass *b1 = f.create("Descendant1");
BaseClass *b2 = f.create("Descendant2");



Related