Using setters in constructor

Question

I'm a Java developer trying to pick up C++. Is it okay to use a setter inside a constructor in order to reuse the sanity checks the setter provides?

For example:

#include <stdexcept>
using namespace std;

class Test {
    private:
        int foo;
        void setFoo(int foo) {
            if (foo < 42) {
                throw invalid_argument{"Foo < 42."};
            }

            this->foo = foo;
        }

    public:
        Test(int foo) {
            setFoo(foo);
        };
};

Answer 1

Yes, it is recommended to do this, basically for the reason you already mentioned.

On the other hand you should ask yourself if you need the setter at all and not directly implement the checks inside the constructor. The reason I am writing this is that setters in general result in mutable state which has many disadvantages as opposed to immutable classes. However sometimes they are required.

Another recommendation: If your class variable is an object and you can modify the constructor of this object, you could put the check into the constructor of this object:

class MyFoo {
public:
    MyFoo(int value) {
        if (value < 42) {
            throw invalid_argument{"Foo < 42."};
        }
        v = value;
    }
private:
    int v;
}

This will enable you to use an initialization list in the constructor of your Test class:

Test(int foo) : foo(foo) {}

However, now the check is a property of the class of the variable and no longer one of the owning class.

Answer 2

Yes you can. It's fine as long as your setters are not virtual, because it's inheritance hierarchy in calling right functions as the "this" ptr is not ready yet.

Here is Herb Sutter GOTW on this matter: http://www.gotw.ca/gotw/066.htm

Answer 3

Yes, that's fine as long as it makes sense to have a setter for a particular member variable (have some logic that can't be checked by assignment only for example) . In this example, setFoo could've just taken an unsigned int and the caller would know not to pass negative values. Which in turn could eliminate the check and thus the need for a setter. For more elaborate checks, a setter and usage of that setter in the constructor is just fine.