Otro uso común-ish es con "objetos de parámetros ". Sin el método de encadenamiento, son bastante incómodos de configurar, pero pueden ser temporales.
En lugar de:
complicated_function(P1 param1 = default1, P2 param2 = default2, P3 param3 = default3);
Comentario:
struct ComplicatedParams {
P1 mparam1;
P2 mparam2;
P3 mparam3;
ComplicatedParams() : mparam1(default1), mparam2(default2), mparam3(default3) {}
ComplicatedParams ¶m1(P1 p) { mparam1 = p; return *this; }
ComplicatedParams ¶m2(P2 p) { mparam2 = p; return *this; }
ComplicatedParams ¶m3(P3 p) { mparam3 = p; return *this; }
};
complicated_function(const ComplicatedParams ¶ms);
Ahora se puede llamar así:
complicated_function(ComplicatedParams().param2(foo).param1(bar));
Lo que significa que la persona que llama no tiene que recordar el orden de los parámetros .Sin el encadenamiento método que tendría que ser:
ComplicatedParams params;
params.param1(foo);
params.param2(bar);
complicated_function(params);
También puede llamar:
complicated_function(ComplicatedParams().param3(baz));
lo que significa que sin tener que definir una tonelada de sobrecargas, puedo especificar sólo el último parámetro y deja el resto por defecto.
El pellizco obvia última es hacer complicated_function
un miembro de ComplicatedParams
:
struct ComplicatedAction {
P1 mparam1;
P2 mparam2;
P3 mparam3;
ComplicatedAction() : mparam1(default1), mparam2(default2), mparam3(default3) {}
ComplicatedAction ¶m1(P1 p) { mparam1 = p; return *this; }
ComplicatedAction ¶m2(P2 p) { mparam2 = p; return *this; }
ComplicatedAction ¶m3(P3 p) { mparam3 = p; return *this; }
run(void);
};
ComplicatedAction().param3(baz).run();
principal inconveniente es que usted podría estar regresando '* this' como un' 'A &, y escribiendo' A * a = new A.; a-> setA(). setB() 'o (más importante)' A b; b.setA(). setB(); '. 'b.setA() -> setB();' es un poco basura ;-) –