Thread: help with classes

you are trying to declare a variable and initialize it at the same time while inside a class.. not good. Instead, declare your variable and then initialize it using a constructor.

Code:

class Classy
{
public:
     
     Classy(){foo=0;}  //Inline function for this example

private:

     int foo;
};

You can have constant data members but they must be initialized in an initializer list:

Code:

class Minesweeper
{
public:
    const int ROW;
    const int COL;
    Minesweeper() : ROW(9), COL(9)  // This part here is the initializer list
    {
        // Rest of constructor code goes here
    }
};

You might want to consider a templated class, you can even have a default grid size if necessary. As an example:

Code:

template <int row=9,int col=9>
class Minesweeper
{
public:
    const int ROW;
    const int COL;
    int grid[row][col];
    Minesweeper():ROW(row),COL(col) {}
};

...

// Create a default minesweeper grid w/ 9 rows, 9 cols
Minesweeper<> easy;

// Create another minesweeper grid w/ 20 rows, 20 cols
Minesweeper<20,20> hard;

Make the constants static:

Code:

class Constants
{
  static const int FOO = 9;
  static const int BAR = 2310;
};

Note that this will not compile on some older compilers, because it was a rater late addition to the standard. The usual workaround is to use an enum:

Code:

class Constants
{
  enum { FOO = 9 };
  enum { BAR = 2310 };
};

The Boost libraries provide a common form with the macro BOOST_STATIC_CONSTANT(Type, assignment). From their description:

onstant members, we must use enums as a workaround if we want the constants to be available at compile-time. This macro gives us a convenient way to declare such constants. For example instead of:

Code:

struct foo{
   static const int value = 2;
};

use:

Code:

struct foo{
   BOOST_STATIC_CONSTANT(int, value = 2);
};

And there's more. Static member constants, even when in-class initialized, still require definitions in exactly one source file. The enums don't. This means you somehow have to decide whether to put the definition there. This is done using the BOOST_NO_INCLASS_MEMBER_INITIALIZATION macro:

Code:

#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
const int Constants::FOO;
const int Constants::BAR;
#endif

Note that these definitions do not have an initializer.

Originally Posted by Last Public Draft of the C++ Standard, §9.4.2/4

If a static data member is of const integral or const enumeration
type, its declaration in the class definition can specify a constant-
initializer which shall be an integral constant expression
(_expr.const_). In that case, the member can appear in integral con-
stant expressions within its scope. The member shall still be defined
in a namespace scope if it is used in the program and the namespace
scope definition shall not contain an initializer.