Fluent interface pattern and std::unique_ptr

Question

I am playing with the fluent interface pattern.

First, I wrote something like that:

class C
{
public:
    C() { }

    C* inParam1(int arg1){ param1 = arg1; return this; }
    C* inParam2(int arg2){ param2 = arg2; return this; }

private:
    int param1;
    int param2;
}

Then I tried to use the std::unique_ptr, but then I realized that I do not know how to "shift" the pointer (this) along the chain. I tried something like:

return std::move(this);

that of course does not work.

How can I do this? Are there any problems doing something like this?

In order to reply to comments like: "do not use pointers": there isn't (yet) any practical reason because I am doing this with pointers, is just something I wonder if can be done this way.

With your recent edit, your class no longer uses dynamic allocation, so what would be the purpose of introducing `std::unique_ptr`, which is meant to take care of dynamically allocated objects? — Benjamin Lindley, May 04 '12 at 14:49

Benjamin Lindley · Accepted Answer · 2012-05-04T14:31:32.370

10

Why do you have to return pointers at all?

class C
{
public:
    C create() { return C(); }

    C & inParam1(int arg1){ param1 = arg1; return *this; }
    C & inParam2(int arg2){ param2 = arg2; return *this; }

private:
    C() { }
    int param1;
    int param2;
};

I must admit I don't understand the purpose of that create function or why the constructor is private or how you actually create objects of this class at all. In my understanding, the class should actually be like this:

class C
{
public:
    C() {}

    C & inParam1(int arg1){ param1 = arg1; return *this; }
    C & inParam2(int arg2){ param2 = arg2; return *this; }

private:        
    int param1;
    int param2;
};

And used like this:

int main()
{
    C().inParam1(10).inParam2(20).whatever();
}

edited May 04 '12 at 14:31

answered May 04 '12 at 14:18

Benjamin Lindley

101,917
9
204
274

1

In this example, what is the value of the `create` method over just making the constructor public? – Sven May 04 '12 at 14:30
@Sven: I noticed that and was editing while you were commenting. – Benjamin Lindley May 04 '12 at 14:32

Sven · Answer 2 · 2012-05-04T14:30:19.937

2

There can be only one std::unique_ptr instance for any given instance (because each would try to delete it and that can be done only once). Therefore, while create can return a std::unique_ptr, the other two methods cannot.

Is there any reason why you don't have the other methods return a reference rather than a pointer? And why don't you just have a public constructor? I don't see the value of the create method in this example.

edited May 04 '12 at 14:30

answered May 04 '12 at 14:18

Sven

21,903
4
56
63

You are right, the create method does not have any sense in my example. – Cristiano May 04 '12 at 14:37

score 1 · Answer 3 · answered May 04 '12 at 14:22

1

You missed one important think from the c++ fluent interface example :

//it doesn't make sense to chain after create(), so don't return *this

Therefore, you shouldn't return anything from your create() method.

However if you still want to return something, at least do not (mis-)use unique_ptr, and just return a new object :

C create() { return C(); }

answered May 04 '12 at 14:22

BЈовић

62,405
41
173
273

That really depends on the way you're using it though. In the OP's example, `create` is used to instantiate the object (though i'm not entirely sure why; what's wrong with having a public constructor in this case?), while in the Wiki example, the `create` method is used to *finalize* the object after you've set all the parameters. – Sven May 04 '12 at 14:29

Fluent interface pattern and std::unique_ptr

3 Answers3