Number of parameters for a constructor

Question

I have a class that needs 12 parameters to be passed to its constructor. So I think that there is something wrong with the design of this class.

I would like to ask if there is any design pattern or a general collection of rules regarding the design of a class, especially its constructor.

A constructor that takes 12 parameters is a code smell. Most likely, your class is trying to do too much. — John Dibling, Jan 04 '11 at 15:55
Have a look at this question: [how-many-variables-should-a-constructor-have](http://stackoverflow.com/questions/1434498/how-many-variables-should-a-constructor-have) Although the OP is using C# the answers are applicable to C++. — Tony, Jan 04 '11 at 09:59

score 38 · Accepted Answer · edited Apr 18 '19 at 09:06

12 parameters definitely sound too many to me. Options to reduce their numbers are:

Introduce Parameter Object by grouping logically related parameters into an object and passing that object instead of the individual parameters.

Introduce a Builder (optionally with method chaining). This does not reduce the actual parameter list but it makes the code more readable, and is especially useful if you have several different creation scenarios with varying parameters. So instead of

MyClass someObject = new MyClass(aFoo, aBar, aBlah, aBaz, aBorp, aFlirp, 
        andAGoo);
MyClass anotherObject = new MyClass(aFoo, null, null, aBaz, null, null, 
        andAGoo);

you can have

MyClass someObject = new MyClassBuilder().withFoo(aFoo).withBar(aBar)
        .withBlah(aBlah).withBaz(aBaz).withBorp(aBorp).withFlirp(aFlirp)
        .withGoo(aGoo).build();
MyClass anotherObject = new MyClassBuilder().withFoo(aFoo).withBaz(aBaz)
        .withGoo(aGoo).build();

(Maybe I should have started with this ;-) Analyse the parameters - Are all of them really needed in the constructor (i.e. mandatory)? If a parameter is optional, you may set it via its regular setter instead of the constructor.

I'd definitely do 3. before I even attempt 1. or 2. :) – Matthieu M. Jan 04 '11 at 16:25 — Matthieu M., Jan 04 '11 at 16:25

score 10 · Answer 2 · edited May 23 '17 at 12:25

If your function takes eleven parameters, you probably have forgotten one more

I love this sentence because it sums it all: Bad design calls for bad design.

I took this is from the book C++ Coding Standards: 101 Rules, Guidelines, And Best Practices by Herb Sutter, Andrei Alexandrescu.

Edit: The direct quote is If you have a procedure with ten parameters, you probably missed some. It is itself a quote from Alan Perlis.

Functions with so many parameters are a symtom of bad design. One of the possibility is to try to encapsulate part of these parameters in an entity/class that has a defined goal. (not a garbage class that would list all parameters without meaningful structure).

Never forget the Single Responsibility Principle As a consequence, classes remain limited in size, and as a consequence, limited in number of member paramters, and thus limited in the size of parameters needed for its constructors. Like one of the comments below says, the class with so much constructor parameters may handle too much futile details independent of its main goal.

A look at this one is advised too: How many parameters are too many?

+1 It is a code smell. Sounds like the class is taking care of to much details. But I think that a parameter class is really just covering up the smell. — daramarak, Jan 04 '11 at 12:37
I looked up the book and yes it's there. The direct quote is "If you have a procedure with ten parameters, you probably missed some". It is itself a quote from [Alan Perlis](https://en.wikipedia.org/wiki/Alan_Perlis). — wardw, Aug 05 '15 at 09:42
@wardw nice. I have included the correct quotation in the answer. — Stephane Rolland, Aug 05 '15 at 10:46

score 6 · Answer 3 · answered Jan 04 '11 at 12:47

12 Parameters, something is most probably wrong with the design.

What is done with the parameters?

Does the class just send them into other constructors? Then perhaps it should just accept interfaces to ready constructed objects.
Is the class large and does a lot of things with all these parameters? Then the class has to much responsibility and should accept classes that takes care of the details instead.
Are there any "clusters" in the parameters? Perhaps are some of the parameters a class in the creation. Encapsulate them and give them the appropriate responsibility.

The alternative is that this is parameters for a lowlevel, performance critical construction, in which case the design just have to take back seat, but that is rarely the case.

score 4 · Answer 4 · answered Jan 04 '11 at 10:02

4

if it is possible you may group the parameters by classes and pass their instances to the constructor.

answered Jan 04 '11 at 10:02

Arseny

7,251
4
37
52

This is the approach taken eg. by Win32 API functions. – Alexandre C. Jan 04 '11 at 10:09

score 2 · Answer 5 · answered Jan 04 '11 at 09:59

2

I think this can be acceptable when using the State pattern for example. However, might I suggest passing the object (if appropriate) that those parameters come from instead? And then in the constructor loading the data from it?

answered Jan 04 '11 at 09:59

Dartoxian

750
1
6
10

Number of parameters for a constructor

5 Answers5