How to validate the initialization of a const member variable before assigning it in C++

Question

Let's say I have this simple class with a const int member variable:

class MyClass{
    public:
        Myclass(int x, int y);
    private:
        const int importantNumber;
        int anotherNumber;
};

MyClass::MyClass(int x, int y) :importantNumber{x}
{
    this->anotherNumber = y;
}

Since int importantNumber is const, I can only set it during the creation of the object by the constructor (with a member initialization list, as seen above).

Now, the question: how could I possibly add validation for argument x given to the constructor before actually creating importantNumber with that value? Is it possible to create a static int MyClass::validation(int a) and use it on the member initialization list of the constructor like importantNumber{validation(x)}?

Even if it's possible, is there a better way to do it?

Answer 1

You just add it.

MyClass::MyClass(int x, int y) : importantNumber{validate(x)}
{
    this->anotherNumber = y;
}

The int validate(int original) function can now return something other than x or throw an exception or assert or ask the user for confirmation, whichever you deem appropriate.

If it is just a simple check and you don't want to write a validate function you can use a lambda:

MyClass::MyClass(int x, int y) :importantNumber{
    [](int number){
        assert(number > 0);
        return number;
    }(x)}
{
    this->anotherNumber = y;
}

Although this can get a bit convoluted if you overdo it.

Answer 2

You can use the ternary operator condition ? true : false in the constructor if you want to validate with a simple condition:

class MyClass{
    public:
        MyClass(int x, int y);
    private:
        const int importantNumber;
        int anotherNumber;
};

MyClass::MyClass(int x, int y) : importantNumber(x > 0 ? x : 0)
{
    this->anotherNumber = y;
}

However, be warned that things can quickly become difficult to read if you overdo it with this operator.

For something more complex, you could do something like this:

int validateIntegral(int x) const
{
    // Do validation on 'x'...

    return x;
}

class MyClass{
    public:
        MyClass(int x, int y);
    private:
        const int importantNumber;
        int anotherNumber;
};

MyClass::MyClass(int x, int y) : importantNumber(validateIntegral(x))
{
    this->anotherNumber = y;
}

Answer 3

Use factory function for creating a class instead of constructor.

class MyClass
{
public:
  static MyClass* create (int x, int y);

private:
  MyClass(int x, int y);

private:
  const int importantNumber;
  int anotherNumber;
};

MyClass* MyClass::create (int x, int y)
{
  return x > 0 ? new MyClass(x, y) : NULL;
}

When you need some advanced validation of parameters, factories have following advantages:

• They avoid creation of object in memory if tests fail
• They have more flexibility over checking parameters in initialization list
• You can return NULL if you dont need exceptions nor you want to have some ".is_valid()" member function for your class.