Question

这是自从阅读Effective Java以来我一直在使用的一个很好的习惯用法。我一直试图找到一个C ++等价物或类似的东西，并没有运气。 GoF书中的传统建筑模式在我的案例中并不适用。这是一个复杂的对象，它有一个非常混乱的构造函数。下面是Java的一个小实现。

class ComplicatedObject {

    private String field1;
    private String field2;
    private int      field3;

    private ComplicatedObject(Builder builder) {

            this.field1 = builder.myField1;
            this.field2 = builder.myField2;
            this.field3 = builder.myField3;

    }

    public static class Builder {

            private String myField1 = "some default";
            private String myField2 = "some other default";
            private int           myField3 = -1;

            public Builder() { }
            public Builder field1(String val) {
                    this.myField1 = val;
                    return this;
            }
            public Builder field2(String val) {
                    this.myField2 = val;
                    return this;
            }
            public Builder field3(int val) {
                    this.myField3 = val;
                    return this;
            }
            public ComplicatedObject build() {
                    return new ComplicatedObject(this);
            }
    }
    public static void main(final String[] args) {
    //built like this

            ComplicatedObject obj = new ComplicatedObject.Builder().field1("blah").field2("lol").field3(4).build();

    }
}

Answer 1

#include <iostream>
#include <string>
using namespace std;

class ComplicatedObject {
    public: class Builder {
            friend class ComplicatedObject;

            private: string myField1;
            private: string myField2;
            private: int    myField3;

            public: Builder()
                    : myField1("some default"),
                     myField2 ("some other default"),
                     myField3(-1)
            { }
            public: Builder& field1(const string& val) {
                    myField1 = val;
                    return *this;
            }
            public: Builder& field2(const string& val) {
                    myField2 = val;
                    return *this;
            }
            public: Builder& field3(int val) {
                    myField3 = val;
                    return *this;
            }
            public: ComplicatedObject build() {
                    return ComplicatedObject(*this);
            }
    };

    private: string field1;
    private: string field2;
    private: int      field3;

    private: ComplicatedObject(const Builder& builder) 
            :field1(builder.myField1),
            field2(builder.myField2),
            field3(builder.myField3)
    {}
};

int main(int argc, char** argv) {
    if (argc < 4) {
        std::cout << "not enough params.";
        return 1;
    }
    ComplicatedObject obj(ComplicatedObject::Builder().field1("blah").field2("lol").field3(4));

}

我做了很少的改动，使它成为C ++，快速，安全。 http://ideone.com/sCH1V

Answer 2

它不仅可以适应C ++，而且习惯用于来自 C ++。

我认为我第一次听说这个成语是在Java出现之前。 IIRC Bjarne Stroustrup在C ++第2版中提到这一点，解释了为什么C ++不需要Smalltalk样式命名参数。

我的日期可能错了，但这在C ++中已经有15年了。

编辑：它似乎首先在 C ++的设计和演变（6.5.1）中首次描述，其中它被称为命名函数参数

在c ++中有效的java builder成语等价？

2 个答案: