Здравствуйте Harut, Вы писали:

H>Спосибо Игорь, Но дело в том. что я не знаю размер массива. я хочу знать есть возможность использовать классы MFC как например CArray для динамического развивание массива?

Есть несколько путей:
1) линеаризация многомерного массива:

template<class TYPE, class ARGTYPE = TYPE>
class CThreeDimArray
{
protected:
  size_t m_xSize, m_ySize, m_zSize; // размеры
  typedef CArray<TYPE, ARGTYPE> array_t;
  array_t m_array;

  // линеаризация
  size_t Index(size_t x, size_t y, size_t z) const
  {
    ASSERT(x < m_xSize && y < m_ySize && z < m_zSize);
    return x + y * m_xSize + z * m_xSize * m_ySize;
  }

public:
  size_t GetXSize() const { return m_xSize; }
  size_t GetYSize() const { return m_ySize; }
  size_t GetZSize() const { return m_zSize; }

  void SetSize(size_t x, size_t y, size_t z)
  {
    m_xSize = x; m_ySize = y; m_zSize = z;
    m_array.SetSize(0); // стираем исходные данные
    m_array.SetSize(x * y * z); // выставляем размер
  }

  TYPE GetAt(int x, int y, int z) const { return m_array.GetAt(Index(x, y, z)); }
  void SetAt(int x, int y, int z, ARGTYPE v) { m_array.SetAt(Index(x, y, z), v); }
};

2) массивы массивов
(будет затруднительно прописывать размеры второго-третьего измерений)

3) разреженные массивы

struct INDEX
{
  int x, y, z;

  INDEX() {}
  INDEX(size_t _x, _y, _z): x(_x), y(_y), z(_z) {}
  INDEX(const INDEX& i): x(i.x), y(i.y), z(i.z) {}

};

operator < (const INDEX& a, const INDEX& b)
{
  return a.x <  b.x ||
         a.x == b.x && (a.y <  b.y ||
                        a.y == b.y && (a.z < b.z)
                       );
}

template<>
BOOL AFXAPI CompareElements(const INDEX* pa, const INDEX* pb)
{
  return (*a) < (*b);
}

template <class TYPE, class ARGTYPE = TYPE>
class CThreeDimArray
{
protected:
  typedef CMap<INDEX, INDEX&, TYPE, ARGTYPE> map_t;
  map_t m_map;
  TYPE m_defvalue;
public:
  // смена значения по ходу работы может привести к интересным последствиям :)
  TYPE GetDefValue() const { return m_defvalue; }
  void SetDefValue(ARGTYPE v) { m_defvalue = v; }

  TYPE GetAt(const INDEX& i) const
  {
    TYPE v;
    if(m_map.Lookup(i, v))
      return v;
    else
      return m_defvalue;
  }
  TYPE SetAt(const INDEX& i, ARGTYPE v, BOOL bStoreDefault = false)
  {

    // лишнего не хранить
    if(!bStoreDefault && m_defvalue == v)
      m_map.RemoveAt(i);
    else

      m_map.SetAt(i, v);
  }
};