Inconsistency in my design of C++

Question

I am currenty doing a Sudoku game in c++. For that , I defined many classes including, class Pos for position, and class Error for maintaining errors.

Now, in class Pos,

class Pos {
    int x;
    int y;
public:
    Pos();
    Pos(Pos const&);
    Pos(int,int);

    void    setPos(int,int);

    void    setx(int);
    void    sety(int);

    int    getx() const ;
    int    gety() const ;

    string getPosReport();

    virtual ~Pos();

}; 

What I have done: I have restricted the value for x and y to lie between 0-9 by writing setx and sety as,

void Pos::setx(int x){
    if((x < 0) & (x > 9))
        throw  Exception("Invalid Position");
    else
        this->x = x;
}

void Pos::sety(int y){
    if((y < 0) & (y > 9)){
        throw Exception("Invalid Position");
    }
    else
        this->y = y;
}

My Problem: How Pos() must be defined.

What I have worked:

1. Removing default constructor, didnt helped me because,

   class Error {
       string errmsg;    
       Pos pos1,pos2; // Pos() must be called!! default constructor cannot be removed!
       bool isError;
       // ...... 
   }
   

2. I can initialize x and y to -1 in Pos() , but I feel that will bring instability in my code.

3. I can have int* x and int* y in class Pos such that I can have x = y = NULL, but I feel Pointers will make my code relatively complex than now.

   so,it will be better if some one gives a solution which stimulates the scenario like x = y = N/A (not applicable)

Answer 1

Give Error only constructors that initialise the Pos member objects. Then you won't need to default-construct Pos anywhere.

Initialising members is done with the "member initialisation list", which you may find after the colon (:) below.

class Error {
   Pos p;

   public:
     Error() : p(1,2) {};
};

This should be covered in your book.

---

• Top credit for correctly identifying valid solutions, and the reasons not to adopt them.

Answer 2

You could use boost::optional in your Pos class too. That is a general way of doing "nulls" in C++.

I'm not saying it's really the best option here. Unless you really want an "uninitialized" state I would just use {0,0} as the "default" position.

Answer 3

You need to either remove the default constructor and force users of your class to use the

Pos(int, int)

version of the constructor, or you need to initialise x and y to something like -1 and ensure you check there values when you use them.

The question to ask is, does it make sense to instantiate an invalid position? If not then remove the default constructor and force your object to be valid upon construction.

Answer 4

Well, for starters, when I implemented Sudoku, I just used an int (in the range [0, 81)) for the position. But...

This is a class with value semantics, so you probably do want some sort of default constructor. There are two valid approaches to this:

• You can just choose some arbitrary position (e.g. 0, 0), and use this. In this case, you can simply provide appropriate default values for Pos(int, int), and let it serve as the default constructor as well. Or:

• You can use sentinal values (-1 would be a good choice here, but any out of range value will do). In this case, you check for the sentinal values for any read access (except copy), and abort if someone tries to use an incorrectly initialized instance.

(And you want to abort in case of error, not throw an exception.)