关于类模版迭代器提出时的错误2

自己在写动态数组的时候遇到的问题。

首先代码如下：

// CMyArray.h: interface for the CMyArray class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_CMYARRAY_H__C38AE5B7_BD54_4FBB_A839_7188271EAD03__INCLUDED_)
#define AFX_CMYARRAY_H__C38AE5B7_BD54_4FBB_A839_7188271EAD03__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <string.h>
#include <iostream>
using namespace std;
#define OUT

// T2: 每次申请空间的增长量
template <class T1, int T2 = 2>
class CMyArray  
{
public:
  class iterator
  {
  public:
    iterator(T1* ipData);
    iterator operator++(int);
    T1 operator*();
    bool operator!=(T1* ipData);
  private:
    T1* m_pData;
  };
  T1* Begin();
  T1* End();
public:
  CMyArray();
    virtual ~CMyArray();
public:
  // 是否为空数组
  inline bool IsEmpty() const;
  // 清空数组
  void Clear();
  // 获取元素个数
  inline int GetLen() const;
  // 获取元素
  bool GetElem(int iIndex, OUT T1& iData);
  // 获取前驱
  bool GetPriorElem(int iIndex, OUT T1& iData);
  // 获取后继
  bool GetAfterElem(int iIndex, OUT T1& iData);
  // 插入到之前
  bool InsertElemPri(int iIndex, T1 iData);
  // 插入到之后
  bool InsertElemAft(int iIndex, T1 iData);
  // 插入到尾部
  bool InsertElem(T1 iData);
  // 删除元素
  bool DeleteElem(int iIndex);
  int& operator[] (int iIndex);
  // 选择法排序
  void Sort();
  // 快速排序
  void QuickSort();
  // 二分查找
  int BinSearch(T1 iData);
  void print();
  void Swap(int iIndex1, int iIndex2);
private:
  void _QuickSort(int iLeft, int iRight);
  // 判断下标是否溢出
  bool IsOverflow(int iIndex) const;
  void Init();
  bool NewSpace();
  bool MoveAndWrite(int iIndex, T1 iData);
private:
  // 数组堆空间指针
  T1* m_pData;
  // 使用长度
  int  m_iCount;
  // 空间长度
  int  m_iSpaceLt;
};

// 迭代器 *********************************
template <class T1, int T2>
CMyArray<T1, T2>::iterator::iterator(T1* ipData)
{
  m_pData = ipData;
}
template <class T1, int T2>
CMyArray<T1, T2>::iterator CMyArray<T1, T2>::iterator::operator++(int)
{
  T1* iTemp = m_pData;
  m_pData++;
  return iTemp;
}

template <class T1, int T2>
T1 CMyArray<T1, T2>::iterator::operator*()
{
  return *m_pData;
}
template <class T1, int T2>
bool CMyArray<T1, T2>::iterator::operator!=(T1* ipData)
{
  return m_pData != ipData;
}
// 迭代器 *********************************
template <class T1, int T2>
CMyArray<T1, T2>::CMyArray()
{
  Init();
}

template <class T1, int T2>
CMyArray<T1, T2>::~CMyArray()
{
  Clear();
}

template <class T1, int T2>
T1* CMyArray<T1, T2>::Begin()
{
  return m_pData;
}

template <class T1, int T2>
T1* CMyArray<T1, T2>::End()
{
  return m_pData + m_iCount;
}

// 是否为空数组
template <class T1, int T2>
bool CMyArray<T1, T2>::IsEmpty() const
{
  if (m_iCount == 0 && m_iSpaceLt == 0)
    return true;
  return false;
}
// 清空数组
template <class T1, int T2>
void CMyArray<T1, T2>::Clear()
{
  if (m_pData != NULL)
  {
    delete[] m_pData;
    m_pData = NULL;
  }
  m_iCount   = 0;
  m_iSpaceLt = 0;
}
// 获取元素个数
template <class T1, int T2>
int CMyArray<T1, T2>::GetLen() const
{
  return m_iCount;
}
// 获取元素
template <class T1, int T2>
bool CMyArray<T1, T2>::GetElem(int iIndex, OUT T1& iData)
{
  if (IsOverflow(iIndex) == false)
  {
    return false;
  }
  iData = m_pData[iIndex];
  return true;
}
// 获取前驱
template <class T1, int T2>
bool CMyArray<T1, T2>::GetPriorElem(int iIndex, OUT T1& iData)
{
  if (GetElem(iIndex-1, iData) == false)
  {
    return false;
  }
  return true;
}
// 获取后继
template <class T1, int T2>
bool CMyArray<T1, T2>::GetAfterElem(int iIndex, OUT T1& iData)
{
  if (GetElem(iIndex+1, iData) == false)
    return false;
  return true;
}
// 插入到之前
template <class T1, int T2>
bool CMyArray<T1, T2>::InsertElemPri(int iIndex, T1 iData)
{
  // 如果没有数据和索引下标溢出则直接返回
  if (IsOverflow(iIndex) == false)
    return false;
  if (MoveAndWrite(iIndex,iData) == false)
    return false;
  return true;
}
// 插入到之后
template <class T1, int T2>
bool CMyArray<T1, T2>::InsertElemAft(int iIndex, T1 iData)
{
  // 1 2  3 {4} .. 5
  if (IsOverflow(iIndex) == false)
    return false;
  return MoveAndWrite(iIndex+2, iData);
}
// 插入到尾部
template <class T1, int T2>
bool CMyArray<T1, T2>::InsertElem(T1 iData)
{
  // 如果当前没有数据，则申请
  if (IsEmpty())
  {
    m_pData = new T1[T2];
    m_iSpaceLt = T2;
  }
  // 有数据满了，申请失败了返回
  else if (!NewSpace())
  {
    return false;
  }
  ++m_iCount;
  m_pData[m_iCount-1] = iData;
  return true;
}
// 删除元素
template <class T1, int T2>
bool CMyArray<T1, T2>::DeleteElem(int iIndex)
{
  if (IsOverflow(iIndex) == false)
    return false;
  for (int i = iIndex; i < m_iCount-1; i++)
    m_pData[i] = m_pData[i+1];
  m_iCount--;
  return true;
}
template <class T1, int T2>
int& CMyArray<T1, T2>::operator[] (int iIndex)
{
  return m_pData[iIndex];
}
// 选择排序
template <class T1, int T2>
void CMyArray<T1, T2>::Sort()
{
  for (int i = 0; i < m_iCount; i++)
  {
    int iMin = i;
    for (int j = i; j < m_iCount; j++)
    {
      if (m_pData[j] < m_pData[iMin])
        iMin = j;
    }
    if (iMin != i)
    {
      T1 iTemp = m_pData[iMin];
      m_pData[iMin] = m_pData[i];
      m_pData[i] = iTemp;
    }
  }
}

// 快速排序
template <class T1, int T2>
void CMyArray<T1, T2>::QuickSort()
{
  _QuickSort(0, m_iCount-1);
}

// 二分查找
template <class T1, int T2>
int CMyArray<T1, T2>::BinSearch(T1 iData)
{
  int iLeft  = 0;
  int iRight = m_iCount-1;
  int iIndex = 0;
  while (iLeft <= iRight)
  {
    iIndex = (iRight+iLeft)/2;
    if (m_pData[iIndex] == iData)
    {
      return iIndex;
    }
    else if (m_pData[iIndex] > iData)
    {
      iRight= iIndex - 1;
    }
    else if (m_pData[iIndex] < iData)
    {
      iLeft = iIndex + 1;
    }
  }
  return -1;
}

template <class T1, int T2>
void CMyArray<T1, T2>::_QuickSort(int iLeft, int iRight)
{
  // 3 2 5 1 4
  int i = iLeft;
  int j = iRight;
  int iIndex = iLeft;
  while(iLeft != iRight)
  {
    // 找右边
    while (iRight > iLeft)
    {
      if (m_pData[iRight] <= m_pData[iIndex])
      {
        Swap(iRight, iIndex);
        iIndex = iRight;
        break;
      }
      iRight--;
    }
    // 找左边
    while (iLeft < iRight)
    {
      if (m_pData[iLeft] > m_pData[iIndex])
      {
        Swap(iLeft, iIndex);
        iIndex = iLeft;
        break;
      }
      iLeft++;
    }
  }
  if (i < iIndex-1)
    _QuickSort(i, iIndex-1);
  if (j > iIndex+1)

    _QuickSort(iIndex+1, j);
}

template <class T1, int T2>
void CMyArray<T1, T2>::Swap(int iIndex1, int iIndex2)
{
  T1 iTemp = m_pData[iIndex1];
  m_pData[iIndex1] = m_pData[iIndex2];
  m_pData[iIndex2] = iTemp;
}

/* private: *************************/
// 判断下标是否溢出
template <class T1, int T2>
bool CMyArray<T1, T2>::IsOverflow(int iIndex) const
{
  // 0 - m_iCount 且数组不为空返回true
  if (iIndex < 0 || iIndex >= m_iCount || m_iSpaceLt == 0)
    return false;
  return true;
}
template <class T1, int T2>
void CMyArray<T1, T2>::Init()
{
  m_pData    = NULL;
  m_iCount   = 0;
  m_iSpaceLt = 0;
}

template <class T1, int T2>
bool CMyArray<T1, T2>::NewSpace()
{
  if (m_iCount == m_iSpaceLt)
  {
    T1* pTemp = new T1[m_iSpaceLt+T2];
    // 申请失败返回,成功则拷贝
    if (!(pTemp))
    {
      return false;
    }
    memcpy(pTemp, m_pData, m_iCount * sizeof(T1));
    delete[] m_pData;
    m_pData = pTemp;
    m_iSpaceLt = m_iSpaceLt+T2;
  }
  return true;
}
template <class T1, int T2>
bool CMyArray<T1, T2>::MoveAndWrite(int iIndex, T1 iData)
{  
  // 如果空间不够新申请并拷贝
  if (!NewSpace())
    return false;
  // 插入数据
  // 特殊情况处理.下标值为0
  if (iIndex != 0)
    iIndex -= 1;
  for (int i = m_iCount; i > iIndex; i--)
    m_pData[i] = m_pData[i-1];
  m_pData[iIndex] = iData;
  m_iCount++;
  return true;
}
template <class T1, int T2>
void CMyArray<T1, T2>::print()
{
  for (int i = 0; i < m_iCount; i++)
    cout << m_pData[i] << " ";
  cout << endl;
}

#endif // !defined(AFX_CMYARRAY_H__C38AE5B7_BD54_4FBB_A839_7188271EAD03__INCLUDED_)

首先要说明的是。vc6.0不支持类中嵌套类的模版提出来的这种写法。

而vc2005则会在这里报错：

template <class T1, int T2>
CMyArray<T1, T2>::iterator CMyArray<T1, T2>::iterator::operator++(int)
{
  T1* iTemp = m_pData;
  m_pData++;
  return iTemp;
}
错误如下：

cmyarray.h(24) : warning C4346: 'CMyArray<T1,T2>::iterator' : dependent name is not a type

蛋疼。