Question

I have abstract class A

class A{
 public:
  A(dim) : dim_(dim);
 private:
  int dim_;
}

and class B

class B : public A{
 public:
  B(int dim);
}

and I need to make constructor for class B, which works only when dim > 1 and throw assertions otherwise.

in this case

B::B(int dim) : A(dim){
  assert(dim > 1);
}

it works, but it’s not good solution I think, because instance of the class A was created and deleted.

Than I make init-method for class A:

class A{
 public:
  void init(int dim){
    dim_ = dim;
  }
  A(int dim){
    init(dim);
  }
 private:
  int dim_;
}

and change constructor of class B:

class B : public A {
 public:
  B(int dim){
    assert(dim > 1);
    init(dim);
  }
}

but it doesn’t work. Is there any possible solutions for my problem?

Answer 1

I think you could write a small myint class which makes sure that the int you pass is always greater than 1:

struct myint
{
    int data; 
    myint(int i) : data(i) { assert(data > 1); }
};

Now use it in your class:

class B : public A{
 public:
  B(myint dim) //this can still take int, due to implicit conversion! 
   : A(dim.data) { }
}

Note that you can still construct B passing int, as it will implicitly convert into myint and while the conversion takes place (implicitly), it will test the assert, and if that succeeds, only then you would be able to pass dim.data to the base class A. If the assert fails, your program will abort before entering into the base class constructor (without initializing anything in derived class also).

---

You could even generalize it as:

//Summary : gint<N> makes sure that data > N
template<int N>
struct gint  //call it greater int
{
    int data; 
    gint(int i) : data(i) { assert(data > N); } //Use N here!
};

Now use it in your class:

class B : public A{
 public:
  B(gint<1> dim) //the template argument 1 makes sure that dim.data > 1
   : A(dim.data) { }
}

If you need another class, for example:

class Xyz : public A{
 public:
  B(gint<10> dim)  //gint<10> makes sure that dim.data > 10
   : A(dim.data) { }
}

Cool, isn’t?