关于c++:谈-C17-里的-Builder-模式

它没什么好说的。

然而它的 builder 会比较复杂，因为这里决定有两种预制的 builder（Jeep 和 Nissan）别离制作不同规格的 Car。所以咱们须要一个抽象类的 builder class，以及一个构建样板类 director，实际上你也能够不用拆散样板类，充分利用多态性也是能够的：

namespace hicc::dp::builder::complex {

  class builder {
    public:
    virtual basis::wheel *get_wheel() = 0;
    virtual basis::engine *get_engine() = 0;
    virtual basis::body *get_body() = 0;
  };

  class director {
    public:
    void set_builder(builder *b) { _builder = b; }

    basis::car *get_car() {
      basis::car *car = new basis::car();

      car->body = _builder->get_body();

      car->engine = _builder->get_engine();

      car->wheels[0] = _builder->get_wheel();
      car->wheels[1] = _builder->get_wheel();
      car->wheels[2] = _builder->get_wheel();
      car->wheels[3] = _builder->get_wheel();

      return car;
    }

    private:
    builder *_builder;
  };

} // namespace hicc::dp::builder::complex

样板类决定了构建 Car 的规范样板。

如果你的确采纳了在抽象类 builder class 中间接实现 get_car() 的代码逻辑，并且使其 virtual 化（这并不是必须的）的话，那么这套做法实际上也援用了模板办法模式（Template Method Pattern）。

模板办法模式（Template Method Pattern）在超类中定义了一个算法的框架， 容许子类在不批改构造的状况下重写算法的特定步骤。

接下来，是具体实现两个 builder 类了：

namespace hicc::dp::builder::complex {

  class jeep_builder : public builder {
    public:
    basis::wheel *get_wheel() {
      basis::wheel *wheel = new basis::wheel();
      wheel->size = 22;
      return wheel;
    }

    basis::engine *get_engine() {
      basis::engine *engine = new basis::engine();
      engine->horsepower = 400;
      return engine;
    }

    basis::body *get_body() {
      basis::body *body = new basis::body();
      body->shape = "SUV";
      return body;
    }
  };

  class nissan_builder : public builder {
    public:
    basis::wheel *get_wheel() {
      basis::wheel *wheel = new basis::wheel();
      wheel->size = 16;
      return wheel;
    }

    basis::engine *get_engine() {
      basis::engine *engine = new basis::engine();
      engine->horsepower = 85;
      return engine;
    }

    basis::body *get_body() {
      basis::body *body = new basis::body();
      body->shape = "hatchback";
      return body;
    }
  };

} // namespace hicc::dp::builder::complex

以及，它的测试代码：

void test_builder_complex() {
  using namespace hicc::dp::builder::complex;

  basis::car *car; // Final product

  /* A director who controls the process */
  director d;

  /* Concrete builders */
  jeep_builder jb;
  nissan_builder nb;

  /* Build a Jeep */
  std::cout <<"Jeep" <specifications();

  std::cout <specifications();
}

留神 Car 由很多部件组合，每个部件也可能有很简单的构建步骤。

优化

当然啰，这个示例仅仅只是示例。在真实世界里，这个示例的实现能够将 jeep_builder 和 nissan_builder 抽出一个公共的基类：

class managed_builder : public builder {
  public:
  basis::wheel *get_wheel() {
    basis::wheel *wheel = new basis::wheel();
    wheel->size = wheel_size;
    return wheel;
  }

  basis::engine *get_engine() {
    basis::engine *engine = new basis::engine();
    engine->horsepower = engine_horsepower;
    return engine;
  }

  basis::body *get_body() {
    basis::body *body = new basis::body();
    body->shape = body_shape;
    return body;
  }

  managed_builder(int ws, int hp, const char *s = "SUV")
    : wheel_size(ws), engine_horsepower(hp), body_shape(s) {}
  int wheel_size;
  int engine_horsepower;
  std::string_view body_shape;
};

岂但有利于打消反复代码片段，而且更能应答未来的扩大，万一想要 BMW 呢。

进一步地泛型化

其实也能够应用模板类的形式：

template
class generic_builder : public builder {
  public:
  basis::wheel *get_wheel() {
    basis::wheel *wheel = new basis::wheel();
    wheel->size = wheel_size;
    return wheel;
  }

  basis::engine *get_engine() {
    basis::engine *engine = new basis::engine();
    engine->horsepower = engine_horsepower;
    return engine;
  }

  basis::body *get_body() {
    basis::body *body = new basis::body();
    body->shape = body_shape;
    return body;
  }
};

constexpr const char suv_str[] = {"SUV"};
constexpr const char hatchback_str[] = {"hatchback"};

class jeep_builder : public generic_builder<22, 400, suv_str> {
  public:
  jeep_builder()
    : generic_builder<22, 400, suv_str>() {}
};

class nissan_builder : public generic_builder<16, 85, hatchback_str> {
  public:
  nissan_builder()
    : generic_builder<16, 85, hatchback_str>() {}
};

这里应用了 constexpr const char suv_str[] 这种技巧，它使得咱们可能设法在模板参数中间接传递字符串的字面量，于是下面的代码就残缺地模板化了。

如果你曾经开始应用 C++20 了，那么 std::basic_fixed_string 可能让你取得间接传递字符串字面量的能力：

template
class generic_builder : public builder {
  // ...
};

class jeep_builder : public generic_builder<22, 400, "SUV"> {
  public:
};

class nissan_builder : public generic_builder<16, 85, "hatchback"> {
  public:
};

如果感兴趣残缺源代码，能够去查阅相干源码 dp-builder.cc。

元编程中的 Builder Pattern

刚刚咱们提前讲述了泛型化一个 builder 的工作，但那只是做了一点初阶的重构而已。而当在模板类体系中须要应用 Builder Pattern 时，状况有一点点变动，特地是当对 builder 的专用代码向上抽出为一个繁多的基类时，咱们须要 CRTP 技术的染指。

CRTP

CRTP 是一种 C++ 习用法，它比 C++11 出世的早得多。在 Visual C++ 年代，ATL，WTL 以及大量的 MFC 均大规模地应用了这种技术，起初的 ProfUIS 也如此。

简略地说，CRTP 的目标在于实现编译期的多态绑定，实现办法是向基类的模板参数中传入派生类类名，于是基类就可能借助 static_cast(*this*) 语法来取得派生类的“多态”的操作能力了：

template 
class base{
  public:
  void do_sth(){
    static_cast(*this*)->show();
  }
  void show(){hicc_debug("base::show");}
};

template 
class derived: public base {
  public:
  T t{};
  void show(){
    hicc_debug("t: %s", hicc::to_string(t).c_str());
  }
};

可继承的 builder pattern

了解 CRTP 技术之后，这里仅仅给出一个示意性的片段：

namespace hicc::dp::builder::meta {
    class builder_base {
    public:
        builder_base &set_a() {
            return (*this);
        }

        builder_base& on_set_b(){
            return (*this);
        }
    };

    template
    class builder : public builder_base {
    public:
        derived_t &set_a() {
            return *static_cast(this);
        }
        derived_t &set_b() {
            return *static_cast(this);
        }

        std::unique_ptr t{}; // the temporary object for builder constructing...

        // ... more
    };

    template
    class jeep_builder : public builder, T> {
    public:
        jeep_builder &set_a() {
            return *this;
        }
    };
} // namespace hicc::dp::builder::meta

void test_builder_meta() {
    using namespace hicc::dp::builder::meta;
    jeep_builder b{};
    b.set_a();
}

在代码中，return *static_case(this) 能够保障总是返回 derived_t& 参考，这就可能保障从派生类中发动的链式调用 jeep_builder().set_a() 可能正确地调用派生类的重载版本（也是一个笼罩式、擦除式的版本），所以不应用 virtual function 的状况下仍可能正确（模仿）多态。

Epilogue

多数的个性有赖于 cxx17 以上的语法反对，但不是必需品。