Thread: problems with constructor

You are getting all of those errors because you need a default constructor. When you instantiate an object of type Board, an 8-by-8 array of Square objects must be contructed. This is done by calling the default constructor which you have not defined. Make a default constructor for your Square class and those errors should disappear. Then I'd suggest some kind of Set member function for the Square class as well that you can call inside that double loop to set whatever value you are trying to set instead of calling another constructor.

You are calling the constructor incorrectly.

The constructor for Square is:

Code:

Square(int);

The constructor for Board is:

Code:

Board();

Yet you do this:

Code:

Square board[col][row]( temp );

Code:

class Square 
{
  public:
    Square(int) { //Zero out members here }
    void            print_square();
  private:
     int             color;
     static const char       red[3];
     static const char       black[3];
};

class Board 
{
  public:
    Board() {m_pSquare=NULL }
    virtual ~Board() {delete m_pSquare;   //Check for validity here if MSVC 6}
    void Create() {m_pSquare=new Square(0); }
    void print_board();
  private:
    Square       *m_pSquare;

Square takes an integer in the constructor but you never use it or even give the parameter a variable name.

I'm assuming you want one Square so you use static. But from what I see your entire design is heading in the wrong direction.

First encapsulate access to a simple linear array.
Second make a class that uses that class to present a game board to the user.

Or just make a Board class that encapsulates an array.

A default constructor will take no parameters, because the compiler has no way of knowing how many parameters you want or need.

Code:

class Foo
{
   int m_iX;
   public:
     void SetX(int value) {m_iX=value;}
     int GetX() {return m_iX;}
};

Foo Object;      //Default constructor is called, m_iX's value is undefined here
Object.SetX(5);  //Now m_iX's value is 5

Good habit to get into:

1. Always provide your own constructor.
2. Always provide a virtual destructor.

Don't rely on the compiler's default constructor to help you at all.

If you don't specify any constructor, then it will create a default one for you. You have however specified a contructor that takes an int argument and the compiler will take that as the only constructor available. When you instantiate an instance of type Board, the compiler will therefore not be able to find the default constructor necessary to create the Square board[8][8] member of your Board class.

In a certain sense, you don't need to know the color of the square. That is just a visual que us humans find easy to deal with. To the Board object, the color of the square can be infered simply by its index values; i.e. [0][0] is red, [0][1] is black... [1][0] is red, [1][1] is black, etc.. What you must keep track of is the color of the piece on a given square, not the color of the square itself and this is what I had thought the color member represented.

If you really want to assign a color to the squares and make them a const member then I would suggest something along the lines of this:

Code:

#include <iostream>

typedef enum color{ RED, BLACK };

class Square
{
    const color type;
    static int sequence;
    static color GetColor()
    {
        if( (sequence / 8) % 2 == 0 ) return static_cast<color>(sequence%2);
        else return static_cast<color>((sequence+1)%2);
    }
public:
    Square() : type(GetColor()) { ++sequence; }
    friend std::ostream& operator<<(std::ostream&,const Square&);
};

std::ostream& operator<<(std::ostream& os,const Square& square)
{
    if( square.type == RED )
        os << "RED";
    else os << "BLACK";

    return os;
}

int Square::sequence = 0;


// Board class
class Board
{
    Square board[8][8];
public:
    void print()
    {
        for( int a = 0; a < 8; ++a )
            for( int b = 0; b < 8; ++b )
            {
                std::cout << "Square[" << a << "]" << "[" << b << "] is "
                    << board[a][b] << std::endl;
            }
    }
};


int main()
{
    Board board;
    board.print();

    return 0;
}

This prints out:

Code:

Square[0][0] is RED
Square[0][1] is BLACK
Square[0][2] is RED
Square[0][3] is BLACK
Square[0][4] is RED
Square[0][5] is BLACK
Square[0][6] is RED
Square[0][7] is BLACK
Square[1][0] is BLACK
Square[1][1] is RED
Square[1][2] is BLACK
Square[1][3] is RED
Square[1][4] is BLACK
Square[1][5] is RED
Square[1][6] is BLACK
Square[1][7] is RED
Square[2][0] is RED
Square[2][1] is BLACK
Square[2][2] is RED
Square[2][3] is BLACK
Square[2][4] is RED
Square[2][5] is BLACK
Square[2][6] is RED
Square[2][7] is BLACK
Square[3][0] is BLACK
Square[3][1] is RED
Square[3][2] is BLACK
Square[3][3] is RED
Square[3][4] is BLACK
Square[3][5] is RED
Square[3][6] is BLACK
Square[3][7] is RED
Square[4][0] is RED
Square[4][1] is BLACK
Square[4][2] is RED
Square[4][3] is BLACK
Square[4][4] is RED
Square[4][5] is BLACK
Square[4][6] is RED
Square[4][7] is BLACK
Square[5][0] is BLACK
Square[5][1] is RED
Square[5][2] is BLACK
Square[5][3] is RED
Square[5][4] is BLACK
Square[5][5] is RED
Square[5][6] is BLACK
Square[5][7] is RED
Square[6][0] is RED
Square[6][1] is BLACK
Square[6][2] is RED
Square[6][3] is BLACK
Square[6][4] is RED
Square[6][5] is BLACK
Square[6][6] is RED
Square[6][7] is BLACK
Square[7][0] is BLACK
Square[7][1] is RED
Square[7][2] is BLACK
Square[7][3] is RED
Square[7][4] is BLACK
Square[7][5] is RED
Square[7][6] is BLACK
Square[7][7] is RED

the array can be initialized just as you would with an ordinary data type:

Code:

struct square { square(int i) { } };

int
main()
{
	square s[4] = {13, 2, 5, 6};
	square m[3][4] = { {13, 2, 5, 6}, {7, 2, 8, 4}, {9, 5, 0, 7} };
}