Lines 9 & 10 (in Board.h) is where I'm encountering problems. The line 10 function is inline, and empty currently, and the line 9 function (operator=) is below in Board.cpp. For operator= I'm getting this error on line 17:

Next: == operator as class member doesn't need two parameters, it only needs one parameter which in the function is compared with the this-instance. Beside this you can implement a global == operator outside of the class, in this case you need two parameters.

At last a hint: a = operator should always return a reference to this in order to allow statements like a=b=c; - i.e.:

Thank you for the clarification. I tried it and realized that I had to const not just the isEmpty function, but also functions that were called from isEmpty, even though they didn't have the board as their parameter! Seems like I would have to do a const_cast to avoid that domino effect.

Thank you for the tip on returning the *this reference. I wonder, though, how you would treat operator+ then? It would need to return a copy, not a reference. If I then return a copy from a new operation, do I need to worry about memory leaks?

you should try to avoid removing const anywhere using a const_cast. A function which is called isEmpty shouldn't need to anyhow modify the object so declaring it const should be possible.

The rules for the const-ness are quite simple: You can only call functions which are declared as const with a const instance. From within a member function which is declared as const you can only call other member functions which are declared as const too.

It is highly recommended to declare functions as const which are not expected to modify the object. In you code IMO even getCell and == operator should be declared as const since from their names they're not expected to modify any members.

And about the return *this; as reference: AFAIK it would even be possible to return *this when the return value is not declared to be a reference, I think even then a=b=c should work, but in this case i.e. b=c will create a copy (when the operator == returns an instance) using the copy constructor - now it's often the case copy constructors are implemented in a way they simply call the assignment operator, so this would lead to infinite loops. With operator + this is not a problem so returning the result by value is ok, memory leaks should be avoided in copy constructor and/or assignment operator.

as the usage of const is an optional thing you were doing to have safer code, using a const_cast is a kind of betraying yourself and it is always a miserable design. as Zoppo has told, nobody would expect that calling IsEmpty() function would modifiy the object. from a designer's view IsEmpty neither should have arguments. you were passing two integers to Board::IsEmpty? does that mean the IsEmpty checks the two arguments whether they were "empty". if so, why it is a member of class Board?

I wonder, though, how you would treat operator+ then? It would need to return a copy, not a reference. If I then return a copy from a new operation, do I need to worry about memory leaks?

the operator+= would also return *this, same as operator=. the operator+ would not, even if you could do it. return *this in operator+ actually is a severe design error. operator+ should be const and definitively need to return the result by value.

if a function returns by value, the result is a tempory which is alive until the next block end }. you don't have to care for leaks. if you return *this you were returning a reference to an existing object which doesn't allocate any extra memory (and therefore never leaks). the greater risk with return values is that you were returning references or pointers of local objects. after the function call, the pointers are invalid and in most cases it would crash sooner or later.