C / C++ / MFC

int iSize =  sizeof(store);

int iCount = sizeof(store)/sizeof(store[0]);

CString store[100];
CString File; 
and int cou=0;
store[cou]=File.

store[cou]=File;
	
int iSize=sizeof(store);

AfxMessageBox(iSize);

#include <iostream>
#include <string>
#include <vector>

using namespace std;
void main()
{

  vector < string > v;

  v.push_back(string("hi,"));
  v.push_back(string("how"));
  v.push_back(string("do you do?"));
  cout << "vector size = " <<  v.size() << endl;
  for (int i=0; i<v.size(); i++)
  {
    cout << v[i] << " ";
  }
  cout << endl;
}

class Block
{
public:
	Block(void);
	Block(int itsShape, int itsColour);
	~Block(void);

	bool isGrounded(void);
	void MoveLeft();
	void MoveRight();
	void MoveDown();
	void Rotate();

	void Render();

private:
	int Shape;
	int Colour;
	bool Grounded;

	Tile* p_TileArray;
};

#include "Block.h"

Block::Block(void)
{
	Grounded = false;
	Shape = (rand() % 7);
	Colour = (rand() % 6);

	p_TileArray = NULL;
	p_TileArray = new Tile[4];

	p_TileArray[0].SetPos(498.0, 82.0);
	p_TileArray[1].SetPos(530.0, 82.0);
	p_TileArray[2].SetPos(498.0, 114.0);
	p_TileArray[3].SetPos(530.0, 114.0);
}

Block::~Block(void)
{
	if (p_TileArray)
	{
		delete [] p_TileArray; //Debug assertion failure / 'vector deleting destructor'
		p_TileArray = NULL;
	}
}

bool Block::isGrounded(void)
{
	return Grounded;
}
void Block::MoveLeft()
{
	if(Grounded == false)
	{
		for(int i = 0; i < (sizeof(p_TileArray) / sizeof(p_TileArray[0])); i++)
		{
			p_TileArray[i].MoveLeft();
		}
	}
}

void Block::MoveRight()
{
	if(Grounded == false)
	{
		for(int i = 0; i < (sizeof(p_TileArray) / sizeof(p_TileArray[0])); i++)
		{
			p_TileArray[i].MoveRight();
		}
	}
}

void Block::MoveDown()
{
	if(Grounded == false)
	{
		for(int i = 0; i < (sizeof(p_TileArray) / sizeof(p_TileArray[0])); i++)
		{
			p_TileArray[i].MoveDown();
		}
	}
}

void Block::Rotate()
{
}

void Block::Render()
{
	for(int i = 0; i < (sizeof(p_TileArray) / sizeof(p_TileArray[0])); i++)
	{
		p_TileArray[i].Render();
	}	
}

for(int i = 0; i < (sizeof(p_TileArray) / sizeof(p_TileArray[0])); i++)

p_TileArray = NULL;
n_TileArray = 4;
p_TileArray = new Tile[n_TileArray];

In block.h
    CArray<Tile, Tile &> m_Tiles;

In block.cpp
  constructor
   m_Tiles.SetSize (4);
   m_Tiles [0].Set....

...
void Block::Render()
{
	for(int i = 0; i < m_Tiles.GetSize (); i++)
	{
		m_Tiles[i].Render();
	}	
}

Tile::Tile(void)
{
	*p_iNumTiles++;
	left = 0;
	top = 0;
	depth = 0;

	sizex = 0;
	sizey = 0;
	sizez = 0;
}

Tile::~Tile(void)
{
	*p_iNumTiles--;
}

Sauce! wrote:

as far as I know, it's not possible to allocate four tile's to each block before compile time

Sauce! wrote:

*p_iNumTiles++;
*p_iNumTiles--;

class theClass
{
public:
theClass(void);
~theClass(void);

private:
static int theCount = 0; //Error!
};

theClass::theClass()
{
theCount++
}

theClass::~theClass()
{
theCount--
}

Header:
class CMyClass
{
public:
    CMyClass ();
    ~CMyClass ();

protected:
   static int g_MyCounter;
};

cpp file:

int CMyClass::g_MyCounter = 0; // initialise it!

CMyClass::CMyClass ()
{
   g_MyCounter++;
}

CMyClass::~CMyClass ();
{
   ASSERT(g_MyCounter); // vulnerable to race conditions in a multithreaded app. Use crit_section if it's that, um, critical
   g_MyCounter--;
}

UINT CMyTopSecretClass::m_wm_SomeMessage = ::RegisterWindowMessage ("CMyTopSecretClass::m_wm_SomeMessage");

Sauce! wrote:

My tile class certainly isn't that large... (half a terabyte if my calculations are correct!)

class Block;   // forward declare, so the compiler knows "Block" is a valid name.

class Tile
{
   ...
   void SetParentBlock (Block *pBlock);  // only needs to know that Block exists, nothing more.
   ...
};

class Block
{
   ...
   Tile m_Tiles [4]; // needs to know all about Block's size, so needs to see it's full definition.
   ...
};