![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to array.ctt CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / mfc / samples / templdef|
Return to array.ctt CVS log | Up to [WindowsNT SDKs] / mstools / mfc / samples / templdef |
1.1 ! root 1: //////////////////////////////////////////////////////////////////////////// ! 2: // class CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE> - an array containing 'TYPE' elements, ! 3: // passed in parameters as ARG_TYPE ! 4: // ! 5: // This is a part of the Microsoft Foundation Classes C++ library. ! 6: // Copyright (C) 1992 Microsoft Corporation ! 7: // All rights reserved. ! 8: // ! 9: // This source code is only intended as a supplement to the ! 10: // Microsoft Foundation Classes Reference and Microsoft ! 11: // QuickHelp documentation provided with the library. ! 12: // See these sources for detailed information regarding the ! 13: // Microsoft Foundation Classes product. ! 14: //////////////////////////////////////////////////////////////////////////// ! 15: ! 16: //$DECLARE_TEMPLATE ! 17: ! 18: //////////////////////////////////////////////////////////////////////////// ! 19: ! 20: template<class TYPE, class ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 21: class CArray : public CObject ! 22: { ! 23: #if IS_SERIAL ! 24: DECLARE_SERIAL(CArray) ! 25: #else ! 26: DECLARE_DYNAMIC(CArray) ! 27: #endif //!IS_SERIAL ! 28: public: ! 29: ! 30: // Construction ! 31: CArray(); ! 32: ! 33: // Attributes ! 34: int GetSize() const ! 35: { return m_nSize; } ! 36: int GetUpperBound() const ! 37: { return m_nSize-1; } ! 38: void SetSize(int nNewSize, int nGrowBy = -1); ! 39: ! 40: // Operations ! 41: // Clean up ! 42: void FreeExtra(); ! 43: void RemoveAll() ! 44: { SetSize(0); } ! 45: ! 46: // Accessing elements ! 47: TYPE GetAt(int nIndex) const ! 48: { ASSERT(nIndex >= 0 && nIndex < m_nSize); ! 49: return m_pData[nIndex]; } ! 50: void SetAt(int nIndex, ARG_TYPE newElement) ! 51: { ASSERT(nIndex >= 0 && nIndex < m_nSize); ! 52: m_pData[nIndex] = newElement; } ! 53: TYPE& ElementAt(int nIndex) ! 54: { ASSERT(nIndex >= 0 && nIndex < m_nSize); ! 55: return m_pData[nIndex]; } ! 56: ! 57: // Potentially growing the array ! 58: void SetAtGrow(int nIndex, ARG_TYPE newElement); ! 59: int Add(ARG_TYPE newElement) ! 60: { int nIndex = m_nSize; ! 61: SetAtGrow(nIndex, newElement); ! 62: return nIndex; } ! 63: ! 64: // overloaded operator helpers ! 65: TYPE operator[](int nIndex) const ! 66: { return GetAt(nIndex); } ! 67: TYPE& operator[](int nIndex) ! 68: { return ElementAt(nIndex); } ! 69: ! 70: // Operations that move elements around ! 71: void InsertAt(int nIndex, ARG_TYPE newElement, int nCount = 1); ! 72: void RemoveAt(int nIndex, int nCount = 1); ! 73: void InsertAt(int nStartIndex, CArray* pNewArray); ! 74: ! 75: // Implementation ! 76: protected: ! 77: TYPE* m_pData; // the actual array of data ! 78: int m_nSize; // # of elements (upperBound - 1) ! 79: int m_nMaxSize; // max allocated ! 80: int m_nGrowBy; // grow amount ! 81: ! 82: public: ! 83: ~CArray(); ! 84: #if IS_SERIAL ! 85: void Serialize(CArchive&); ! 86: #endif //IS_SERIAL ! 87: #ifdef _DEBUG ! 88: void Dump(CDumpContext&) const; ! 89: void AssertValid() const; ! 90: #endif ! 91: }; ! 92: ! 93: //$IMPLEMENT_TEMPLATE ! 94: ! 95: ///////////////////////////////////////////////////////////////////////////// ! 96: // ! 97: // Implementation of Array of TYPEs ! 98: // ! 99: ///////////////////////////////////////////////////////////////////////////// ! 100: // NOTE: we allocate an array of 'm_nMaxSize' elements, but only ! 101: // the current size 'm_nSize' contains properly constructed ! 102: // objects. ! 103: ! 104: #include "afxcoll.h" ! 105: #pragma hdrstop ! 106: ! 107: #ifdef AFX_COLL_SEG ! 108: #pragma code_seg(AFX_COLL_SEG) ! 109: #endif ! 110: ! 111: #include <limits.h> ! 112: #define SIZE_T_MAX UINT_MAX /* max size for a size_t */ ! 113: ! 114: #if IS_SERIAL ! 115: IMPLEMENT_SERIAL(CArray, CObject, 0); ! 116: #else ! 117: IMPLEMENT_DYNAMIC(CArray, CObject); ! 118: #endif //!IS_SERIAL ! 119: ! 120: #ifdef _DEBUG ! 121: #undef THIS_FILE ! 122: static char BASED_CODE THIS_FILE[] = __FILE__; ! 123: #endif ! 124: ! 125: #define new DEBUG_NEW ! 126: ! 127: ///////////////////////////////////////////////////////////////////////////// ! 128: ! 129: #if HAS_CREATE ! 130: #include "elements.h" // used for special creation ! 131: ! 132: static void NEAR ConstructElements(register TYPE* pNewData, int nCount) ! 133: { ! 134: ASSERT(nCount >= 0); ! 135: ! 136: while (nCount--) ! 137: { ! 138: ConstructElement(pNewData); ! 139: pNewData++; ! 140: } ! 141: } ! 142: ! 143: static void NEAR DestructElements(register TYPE* pOldData, int nCount) ! 144: { ! 145: ASSERT(nCount >= 0); ! 146: ! 147: while (nCount--) ! 148: { ! 149: pOldData->Empty(); ! 150: pOldData++; ! 151: } ! 152: } ! 153: #endif //HAS_CREATE ! 154: ! 155: ///////////////////////////////////////////////////////////////////////////// ! 156: ! 157: template<class TYPE, class ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 158: CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE>::CArray() ! 159: { ! 160: m_pData = NULL; ! 161: m_nSize = m_nMaxSize = m_nGrowBy = 0; ! 162: } ! 163: ! 164: template<class TYPE, ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 165: CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE>::~CArray() ! 166: { ! 167: ASSERT_VALID(this); ! 168: ! 169: #if HAS_CREATE ! 170: DestructElements(m_pData, m_nSize); ! 171: #endif //HAS_CREATE ! 172: delete [] (BYTE*)m_pData; ! 173: } ! 174: ! 175: template <class TYPE, class ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 176: void CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE>::SetSize(int nNewSize, int nGrowBy /* = -1 */) ! 177: { ! 178: ASSERT_VALID(this); ! 179: ASSERT(nNewSize >= 0); ! 180: ! 181: if (nGrowBy != -1) ! 182: m_nGrowBy = nGrowBy; // set new size ! 183: ! 184: if (nNewSize == 0) ! 185: { ! 186: // shrink to nothing ! 187: #if HAS_CREATE ! 188: DestructElements(m_pData, m_nSize); ! 189: #endif //HAS_CREATE ! 190: delete [] (BYTE*)m_pData; ! 191: m_pData = NULL; ! 192: m_nSize = m_nMaxSize = 0; ! 193: } ! 194: else if (m_pData == NULL) ! 195: { ! 196: // create one with exact size ! 197: #ifdef SIZE_T_MAX ! 198: ASSERT((long)nNewSize * sizeof(TYPE) <= SIZE_T_MAX); // no overflow ! 199: #endif ! 200: m_pData = (TYPE*) new BYTE[nNewSize * sizeof(TYPE)]; ! 201: #if HAS_CREATE ! 202: ConstructElements(m_pData, nNewSize); ! 203: #else ! 204: memset(m_pData, 0, nNewSize * sizeof(TYPE)); // zero fill ! 205: #endif ! 206: m_nSize = m_nMaxSize = nNewSize; ! 207: } ! 208: else if (nNewSize <= m_nMaxSize) ! 209: { ! 210: // it fits ! 211: if (nNewSize > m_nSize) ! 212: { ! 213: // initialize the new elements ! 214: #if HAS_CREATE ! 215: ConstructElements(&m_pData[m_nSize], nNewSize-m_nSize); ! 216: #else ! 217: memset(&m_pData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(TYPE)); ! 218: #endif ! 219: } ! 220: #if HAS_CREATE ! 221: else if (m_nSize > nNewSize) // destroy the old elements ! 222: DestructElements(&m_pData[nNewSize], m_nSize-nNewSize); ! 223: #endif ! 224: m_nSize = nNewSize; ! 225: } ! 226: else ! 227: { ! 228: // Otherwise grow array ! 229: int nNewMax; ! 230: if (nNewSize < m_nMaxSize + m_nGrowBy) ! 231: nNewMax = m_nMaxSize + m_nGrowBy; // granularity ! 232: else ! 233: nNewMax = nNewSize; // no slush ! 234: ! 235: #ifdef SIZE_T_MAX ! 236: ASSERT((long)nNewMax * sizeof(TYPE) <= SIZE_T_MAX); // no overflow ! 237: #endif ! 238: TYPE* pNewData = (TYPE*) new BYTE[nNewMax * sizeof(TYPE)]; ! 239: ! 240: // copy new data from old ! 241: memcpy(pNewData, m_pData, m_nSize * sizeof(TYPE)); ! 242: ! 243: // construct remaining elements ! 244: ASSERT(nNewSize > m_nSize); ! 245: #if HAS_CREATE ! 246: ConstructElements(&pNewData[m_nSize], nNewSize-m_nSize); ! 247: #else ! 248: memset(&pNewData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(TYPE)); ! 249: #endif ! 250: ! 251: // get rid of old stuff (note: no destructors called) ! 252: delete [] (BYTE*)m_pData; ! 253: m_pData = pNewData; ! 254: m_nSize = nNewSize; ! 255: m_nMaxSize = nNewMax; ! 256: } ! 257: } ! 258: ! 259: template <class TYPE, class ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 260: void CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE>::FreeExtra() ! 261: { ! 262: ASSERT_VALID(this); ! 263: ! 264: if (m_nSize != m_nMaxSize) ! 265: { ! 266: // shrink to desired size ! 267: #ifdef SIZE_T_MAX ! 268: ASSERT((long)m_nSize * sizeof(TYPE) <= SIZE_T_MAX); // no overflow ! 269: #endif ! 270: TYPE* pNewData = (TYPE*) new BYTE[m_nSize * sizeof(TYPE)]; ! 271: // copy new data from old ! 272: memcpy(pNewData, m_pData, m_nSize * sizeof(TYPE)); ! 273: ! 274: // get rid of old stuff (note: no destructors called) ! 275: delete [] (BYTE*)m_pData; ! 276: m_pData = pNewData; ! 277: m_nMaxSize = m_nSize; ! 278: } ! 279: } ! 280: ! 281: ///////////////////////////////////////////////////////////////////////////// ! 282: ! 283: template <class TYPE, class ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 284: void CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE>::SetAtGrow(int nIndex, ARG_TYPE newElement) ! 285: { ! 286: ASSERT(nIndex >= 0); ! 287: if (nIndex >= m_nSize) ! 288: SetSize(nIndex+1); ! 289: m_pData[nIndex] = newElement; ! 290: } ! 291: ! 292: template <class TYPE, class ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 293: void CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE>::InsertAt(int nIndex, ARG_TYPE newElement, int nCount /*=1*/) ! 294: { ! 295: ASSERT_VALID(this); ! 296: ASSERT(nIndex >= 0); // will expand to meet need ! 297: ASSERT(nCount > 0); // zero or negative size not allowed ! 298: ! 299: if (nIndex >= m_nSize) ! 300: { ! 301: // adding after the end of the array ! 302: SetSize(nIndex + nCount); // grow so nIndex is valid ! 303: } ! 304: else ! 305: { ! 306: // inserting in the middle of the array ! 307: int nOldSize = m_nSize; ! 308: SetSize(m_nSize + nCount); // grow it to new size ! 309: // shift old data up to fill gap ! 310: memmove(&m_pData[nIndex+nCount], &m_pData[nIndex], ! 311: (nOldSize-nIndex) * sizeof(TYPE)); ! 312: ! 313: // re-init slots we copied from ! 314: #if HAS_CREATE ! 315: ConstructElements(&m_pData[nIndex], nCount); ! 316: #else ! 317: memset(&m_pData[nIndex], 0, nCount * sizeof(TYPE)); ! 318: #endif ! 319: } ! 320: ! 321: // insert new value in the gap ! 322: ASSERT(nIndex + nCount <= m_nSize); ! 323: while (nCount--) ! 324: m_pData[nIndex++] = newElement; ! 325: } ! 326: ! 327: template <class TYPE, class ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 328: void CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE>::RemoveAt(int nIndex, int nCount /* = 1 */) ! 329: { ! 330: ASSERT_VALID(this); ! 331: ASSERT(nIndex >= 0); ! 332: ASSERT(nCount >= 0); ! 333: ASSERT(nIndex + nCount <= m_nSize); ! 334: ! 335: // just remove a range ! 336: int nMoveCount = m_nSize - (nIndex + nCount); ! 337: #if HAS_CREATE ! 338: DestructElements(&m_pData[nIndex], nCount); ! 339: #endif ! 340: if (nMoveCount) ! 341: memcpy(&m_pData[nIndex], &m_pData[nIndex + nCount], ! 342: nMoveCount * sizeof(TYPE)); ! 343: m_nSize -= nCount; ! 344: } ! 345: ! 346: template <class TYPE, class ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 347: void CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE>::InsertAt(int nStartIndex, CArray* pNewArray) ! 348: { ! 349: ASSERT_VALID(this); ! 350: ASSERT(pNewArray != NULL); ! 351: ASSERT(pNewArray->IsKindOf(RUNTIME_CLASS(CArray))); ! 352: ASSERT_VALID(pNewArray); ! 353: ASSERT(nStartIndex >= 0); ! 354: ! 355: if (pNewArray->GetSize() > 0) ! 356: { ! 357: InsertAt(nStartIndex, pNewArray->GetAt(0), pNewArray->GetSize()); ! 358: for (int i = 0; i < pNewArray->GetSize(); i++) ! 359: SetAt(nStartIndex + i, pNewArray->GetAt(i)); ! 360: } ! 361: } ! 362: ! 363: ///////////////////////////////////////////////////////////////////////////// ! 364: // Serialization ! 365: ! 366: template<class TYPE, class ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 367: #if IS_SERIAL ! 368: void CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE>::Serialize(CArchive& ar) ! 369: { ! 370: ASSERT_VALID(this); ! 371: ! 372: CObject::Serialize(ar); ! 373: ! 374: if (ar.IsStoring()) ! 375: { ! 376: ar << (WORD) m_nSize; ! 377: for (int i = 0; i < m_nSize; i++) ! 378: ar << m_pData[i]; ! 379: } ! 380: else ! 381: { ! 382: WORD nOldSize; ! 383: ar >> nOldSize; ! 384: SetSize(nOldSize); ! 385: ! 386: for (int i = 0; i < m_nSize; i++) ! 387: ar >> m_pData[i]; ! 388: } ! 389: } ! 390: #endif //IS_SERIAL ! 391: ! 392: ///////////////////////////////////////////////////////////////////////////// ! 393: // Diagnostics ! 394: ! 395: #ifdef _DEBUG ! 396: template <class TYPE, class ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 397: void CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE>::Dump(CDumpContext& dc) const ! 398: { ! 399: ASSERT_VALID(this); ! 400: ! 401: #define MAKESTRING(x) #x ! 402: dc << "a " MAKESTRING(CArray) " with " << m_nSize << " elements"; ! 403: #undef MAKESTRING ! 404: if (dc.GetDepth() > 0) ! 405: { ! 406: dc << "\n"; ! 407: for (int i = 0; i < m_nSize; i++) ! 408: dc << "\n\t[" << i << "] = " << m_pData[i]; ! 409: } ! 410: } ! 411: ! 412: template <class TYPE, class ARG_TYPE, int IS_SERIAL, int HAS_CREATE> ! 413: void CArray<TYPE, ARG_TYPE, IS_SERIAL, HAS_CREATE>::AssertValid() const ! 414: { ! 415: CObject::AssertValid(); ! 416: if (m_pData == NULL) ! 417: { ! 418: ASSERT(m_nSize == 0); ! 419: ASSERT(m_nMaxSize == 0); ! 420: } ! 421: else ! 422: { ! 423: ASSERT(m_nSize <= m_nMaxSize); ! 424: } ! 425: } ! 426: #endif //_DEBUG ! 427: ! 428: ///////////////////////////////////////////////////////////////////////////// ! 429:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.