I am trying to create an array of objects inside a header file which is failing (Starting C++ Programmer)

Question

EDITED BELOW FOR UPDATES!!! Thank you for the help, please by all means point out ALL mistakes , I don't care if it sounds rude or mean or whatever, emo junk. Just give it to me straight so I can understand what is going wrong.

Hi everyone!

I am a rookie C++ programmer trying to learn and gain some IRL exp for C++.

I am attempting the following inside my VC++ (vs2008) compiler:

typedef unsigned short USHORT;

class Grid  
{  
...
public:  
    Grid()  
    {  
        Tile[36]* tileList_ptr;
    }  
...
};

In essence, I want to put 36 tiles , slam them into an array nice and tidy on the heap for a 8x8 playfield that never changes in size. Like a chessboard. Refer to them with a pointer, and fiddle with them in the related cpp file if needed.

If you aren't laughing by now at this attempt then I probably made a syntax error instead of major design flaw :P

Any help would be much appreciated!

Thanks in advance

EDIT 24/08/2010 13:49 (Time of start)

My code is now as following example:

The Grid Header file Grid.h:

#include "Tile.h"

class Grid
{

//no more typedef used

public: 
    Tile grid[8][8];

private:    
    unsigned short selectedItemIndexValue;
public:
    Grid()
    {

        Initialize();       
    }
    ~Grid(){}

    void Update();
    void FinalizeMove(unsigned short index);
    void Draw();

private:
    void Initialize(); //Initializes members
};

The Grid.cpp file:

#include "stdafx.h"   
#include "Grid.h"   
//Not tile , that used to give me a class redefinition error

unsigned short selectedItemIndexValue;

//No more typedef used

void Grid::Update()
{
    //Respond to controller commands
}

void Grid::FinalizeMove(unsigned short index)
{

}

void Grid::Draw()
{

}

void Grid::Initialize()
{
    for(int i = 0; i < 4; i++)
    {
        Grid::grid[i] = new Tile::Tile(10,10);   // ATTEMPT AT FILLING ARRAY
    }
}

Tile.h file

class Tile
{       
public:

private:
    enum TileOccupation
    {
        EmptyTile = 0,
        WhiteSphere = 1,
        BlackSphere = 2
    };

    unsigned short horizontalDimensions;
    unsigned short verticalDimensions;

public:
    Tile(){}    
    ~Tile(){}

void Update();
void Draw();

};

Tile.cpp file:

#include "stdafx.h"
#include "Tile.h"

void Tile::Update()
{

}

void Tile::Draw()
{

}

The attempt at filling the array in Grid.cpp is returning via the compiler the following error message: "Error 1 error C2061: syntax error : identifier '{ctor}'"

MSDN helped me giving me this:

"Compiler Error C2061. The compiler found an identifier where it wasn't expected. Make sure that identifier is declared before you use it."

I have failed at analysing it's meaning. What exactly have I done wrong here ? And what other problems are there to be found in my project? All help and comments will be much appreciated. Just assume I know 0% of C++

Answer 1

@user428435. Three things:

1. 8x8 is 64, not 36
2. What kind of problems are you having? If a compilation error, what is the error? Often careful reading of the errors can help you solve your problems. If the code compiles and runs, what does it do that you don't expect it to do?

3. You probably meant

   Tile* tileList_ptr[36];

Answer 2

If you want to allocate memory on the Heap, you have to use an allocation operator like "malloc" or "new" Your example would, if written correctly only increase the Constructors stack size.

Correct Version of the Stack Memory:

Tile tileList_ptr[36];

Correct Version of the Heap Memory:

Tile* tileList_ptr = new Tile[36];

However, if you use "new" or "malloc" you have to remember to use "delete" or "free" when you don't need the allocated memory anymore...

Answer 3

typedef unsigned short Tile;  // <= assuming typo

class Grid  
{  
...
public:  
    Grid()  
    {
    }  
...
private: 
    Tile tileList[64]; // <= 8x8=64
};

If the number of tiles is fixed at compile-time, why not store an array of tiles, instead of an array of pointers to tiles?

Answer 4

I am laughing. Your code, it's kind of full of fail :P

First tip: If you can avoid heap allocating, do. If your playfield is always 8x8, don't waste time with the heap (allocating the actual game class on the heap is another matter).

Second tip: Don't do that crappy typedef unsigned short USHORT thing. It's an unsigned short. Just use the type directly. USHORT is not going to change to not be an unsigned short. Plus, ALLCAPS names are reserved for macros. You probably picked this up from the Windows headers, they also use this. Really, it's a TERRIBLE idea.

Thirdly, 8x8 = 64, not 36, and you can just directly say 8x8.

What you want is something like this:

class Grid {
    Tile grid[8][8];
public:
    Grid() {
    }
    Tile* operator[](int index) {
        return grid[index];
    }
    const Tile* operator[](int index) const {
        return grid[index];
    }
    ...
};

Answer 5

Possibly you mean this:

Tile tileList_ptr[36];

or this:

Tile* tileList_ptr[36];