パッケージSTLのvectorはMFCのCArryインターフェースを提供します.
11532 ワード
パッケージSTLのvectorはMFCのCArryインターフェースを提供します.
STLテンプレートライブラリのvector配列をカプセル化することにより、MFCのCArrayの関連機能を提供し、vectorアクセスインターフェースを提供する.
STLテンプレートライブラリのvector配列をカプセル化することにより、MFCのCArrayの関連機能を提供し、vectorアクセスインターフェースを提供する.
//////////////////////////////////////////////////////////////////////////
// STL vector ， MFC CArray ， vector
//////////////////////////////////////////////////////////////////////////
#ifndef __CARRAYEX_H__
#define __CARRAYEX_H__
#include
#if !defined(_WIN32)
#include
#endif
//
template
class CArrayEx
{
public:
typedef TYPE _Ty;
typedef CArrayEx _Myt;
typedef typename std::vector::size_type size_type;
typedef typename std::vector::const_iterator const_iterator;
typedef typename std::vector::iterator iterator;
typedef typename std::vector::const_reverse_iterator const_reverse_iterator;
typedef typename std::vector::reverse_iterator reverse_iterator;
typedef typename std::vector::const_reference const_reference;
typedef typename std::vector::reference reference;
//
CArrayEx();
//
~CArrayEx();
//
INT_PTR GetSize() const;
//
INT_PTR GetCount() const;
//
BOOL IsEmpty() const;
// ， ， -1
INT_PTR GetUpperBound() const;
//
void SetSize(INT_PTR nNewSize, INT_PTR nGrowBy = -1);
//
const TYPE& GetAt(INT_PTR nIndex) const;
//
TYPE& GetAt(INT_PTR nIndex);
//
void SetAt(INT_PTR nIndex, TYPE const& newElement);
//
const TYPE& ElementAt(INT_PTR nIndex) const;
//
TYPE& ElementAt(INT_PTR nIndex);
// ，
const TYPE* GetData() const;
// ，
TYPE* GetData();
//
std::vector* GetArray();
// ， ，
void SetAtGrow(INT_PTR nIndex, TYPE const& newElement);
//
INT_PTR Add(TYPE const& newElement);
// ，
INT_PTR Append(const CArrayEx& src);
// ，
void Copy(const CArrayEx& src);
//
// ，
const TYPE& operator[](INT_PTR nIndex) const;
// ，
TYPE& operator[](INT_PTR nIndex);
//
void InsertAt(INT_PTR nIndex, TYPE const& newElement, INT_PTR nCount = 1);
//
void RemoveAt(INT_PTR nIndex, INT_PTR nCount = 1);
//
void InsertAt(INT_PTR nStartIndex, CArrayEx const *pNewArray);
//
void FreeExtra();
//
void RemoveAll();
// CArrayEx vector ， ，
void reserve(size_type _Count) { m_vtArray.reserve(_Count);}
size_type capacity() const { return m_vtArray.capacity();}
iterator begin() { return m_vtArray.begin();}
const_iterator begin() const { return m_vtArray.begin();}
iterator end() { return m_vtArray.end();}
const_iterator end() const { return m_vtArray.end();}
reverse_iterator rbegin() { return m_vtArray.rbegin();}
const_reverse_iterator rbegin() const { return m_vtArray.rbegin();}
reverse_iterator rend() { return m_vtArray.rend();}
const_reverse_iterator rend() const { return m_vtArray.rend();}
void resize(size_type _Newsize) { m_vtArray.resize(_Newsize);}
void resize(size_type _Newsize, TYPE _Val) { m_vtArray.resize(_Newsize,_Val);}
size_type size() const { return m_vtArray.size();}
size_type max_size() const { return m_vtArray.max_size();}
bool empty() const { return m_vtArray.empty();}
const_reference at(size_type _Pos) const{ return m_vtArray.at(_Pos);}
reference at(size_type _Pos) { return m_vtArray.at(_Pos);}
reference front() { return m_vtArray.front();}
const_reference front() const { return m_vtArray.front();}
reference back() { return m_vtArray.back();}
const_reference back() const { return m_vtArray.back();}
void push_back(const TYPE& _Val) { m_vtArray.push_back(_Val);}
void pop_back() { m_vtArray.pop_back();}
template
void assign(_Iter _First, _Iter _Last) { m_vtArray.template assign<_iter>(_First, _Last);}
void assign(size_type _Count, const _Ty& _Val) { m_vtArray.assign(_Count, _Val);}
iterator insert(iterator _Where, const _Ty& _Val) { return m_vtArray.insert(_Where, _Val);}
void insert(iterator _Where, size_type _Count, const _Ty& _Val) { m_vtArray.insert(_Where, _Count, _Val);}
template
void insert(iterator _Where, _Iter _First, _Iter _Last) { m_vtArray.template insert<_iter>(_Where, _First, _Last);}
iterator erase(iterator _Where) { return m_vtArray.erase(_Where);}
void clear() { m_vtArray.clear();}
void swap(_Myt& _Right) { m_vtArray.swap(_Right.m_vtArray);}
protected:
std::vector m_vtArray;// vector
friend bool operator== (CArrayEx const &lhs, CArrayEx const &rhs);
};
//////////////////////////////////////////////////////////////////////////
//
template
CArrayEx::CArrayEx()
{
}
//
template
CArrayEx::~CArrayEx()
{
m_vtArray.clear();
}
//
template
inline INT_PTR CArrayEx::GetSize() const
{
return static_cast(m_vtArray.size());
}
//
template
inline INT_PTR CArrayEx::GetCount() const
{
return static_cast(m_vtArray.size());
}
//
template
inline BOOL CArrayEx::IsEmpty() const
{
return m_vtArray.empty() ? TRUE : FALSE;
}
// ， ， -1
template
inline INT_PTR CArrayEx::GetUpperBound() const
{
return static_cast(m_vtArray.size()) - 1;
}
// , vector
template
void CArrayEx::SetSize(INT_PTR nNewSize, INT_PTR /*nGrowBy = -1*/)
{
m_vtArray.resize(nNewSize);
}
//
template
const TYPE& CArrayEx::GetAt(INT_PTR nIndex) const
{
// ，
if (nIndex >= 0 && nIndex < static_cast(m_vtArray.size()))
return m_vtArray[nIndex];
throw std::runtime_error("Invalid array index!");
}
//
template
TYPE& CArrayEx::GetAt(INT_PTR nIndex)
{
// ，
return m_vtArray.at(nIndex);
}
//
template
void CArrayEx::SetAt(INT_PTR nIndex, TYPE const& newElement)
{
// ，
if (nIndex >= 0 && nIndex < static_cast(m_vtArray.size()))
m_vtArray[nIndex] = newElement;
else
throw std::runtime_error("Invalid array index!");
}
//
template
const TYPE& CArrayEx::ElementAt(INT_PTR nIndex) const
{
// ，
if (nIndex >= 0 && nIndex < static_cast(m_vtArray.size()))
return m_vtArray[nIndex];
throw std::runtime_error("Invalid array index!");
}
//
template
TYPE& CArrayEx::ElementAt(INT_PTR nIndex)
{
// ，
if (nIndex >= 0 && nIndex < static_cast(m_vtArray.size()))
return m_vtArray[nIndex];
throw std::runtime_error("Invalid array index!");
}
// ，
template
inline const TYPE* CArrayEx::GetData() const
{
// ，
if( !m_vtArray.empty() )
{
return &m_vtArray[0];
}
// ，
return NULL;
}
// ，
template
inline TYPE* CArrayEx::GetData()
{
// ，
if( !m_vtArray.empty() )
{
return &m_vtArray[0];
}
// ，
return NULL;
}
//
template
inline std::vector* CArrayEx::GetArray()
{
return &m_vtArray;
}
// ， ，
template
void CArrayEx::SetAtGrow(INT_PTR nIndex, TYPE const& newElement)
{
// 0
if (nIndex >= 0)
{
if (nIndex >= static_cast(m_vtArray.size()))
m_vtArray.resize(nIndex + 1, newElement);
else
m_vtArray[nIndex] = newElement;
}
}
//
template
inline INT_PTR CArrayEx::Add(TYPE const& newElement)
{
m_vtArray.push_back(newElement);
return static_cast(m_vtArray.size() - 1);
}
// ，
template
INT_PTR CArrayEx::Append(const CArrayEx& src)
{
if (src.m_vtArray.empty())
return -1;
INT_PTR iOldIndex = static_cast(m_vtArray.size());
m_vtArray.insert(m_vtArray.end(), src.m_vtArray.begin(), src.m_vtArray.end());
return iOldIndex;
}
// ，
template
inline void CArrayEx::Copy(const CArrayEx& src)
{
m_vtArray.assign(src.m_vtArray.begin(), src.m_vtArray.end());
}
// ，
template
inline const TYPE& CArrayEx::operator[](INT_PTR nIndex) const
{
return m_vtArray[nIndex];
}
// ，
template
inline TYPE& CArrayEx::operator[](INT_PTR nIndex)
{
return m_vtArray[nIndex];
}
//
template
void CArrayEx::InsertAt(INT_PTR nIndex, TYPE const& newElement, INT_PTR nCount /*= 1*/)
{
//
if (nCount <= 0)
return;
// ，
if (nIndex >= static_cast(m_vtArray.size()))
{
m_vtArray.resize(nIndex + nCount, newElement);
}
//
else
{
m_vtArray.insert(m_vtArray.begin() + nIndex, nCount, newElement);
}
}
//
template
void CArrayEx::RemoveAt(INT_PTR nIndex, INT_PTR nCount /*= 1*/)
{
//
if (nIndex >= 0 && nIndex < static_cast(m_vtArray.size()) && nCount > 0)
{
INT_PTR iLeaveCount = static_cast(m_vtArray.end() - (m_vtArray.begin() + nIndex));
iLeaveCount = iLeaveCount > nCount ? nCount : iLeaveCount;
m_vtArray.erase(m_vtArray.begin() + nIndex, m_vtArray.begin() + nIndex + iLeaveCount);
}
}
//
template
void CArrayEx::InsertAt(INT_PTR nStartIndex, CArrayEx const *pNewArray)
{
//
if (!pNewArray)
return;
if (pNewArray->m_vtArray.empty())
return;
// ，
if (nStartIndex >= static_cast(m_vtArray.size()))
{
m_vtArray.resize(nStartIndex + 1);
m_vtArray.insert(m_vtArray.end(), pNewArray->m_vtArray.begin(), pNewArray->m_vtArray.end());
}
//
else
{
m_vtArray.insert(m_vtArray.begin() + nStartIndex, pNewArray->m_vtArray.begin(), pNewArray->m_vtArray.end());
}
}
//
template
inline void CArrayEx::FreeExtra()
{
return;
}
//
template
inline void CArrayEx::RemoveAll()
{
m_vtArray.clear();
}
template
inline bool operator== (CArrayEx const &lhs, CArrayEx const &rhs)
{
return lhs.m_vtArray == rhs.m_vtArray;
}
//////////////////////////////////////////////////////////////////////////
#endif