Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!
Werbeanzeige
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
#endif /* CRTDLL */ else // __active_heap == __SYSTEM_HEAP #endif /* _WIN64 */ { retval = HeapFree(_crtheap, 0, pBlock); //<=== AN DIESER STELLE! if (retval == 0) { errno = _get_errno_from_oserr(GetLastError()); } } } #else /* WINHEAP */ |
Administrator
Zitat von »"Black-Panther"«
PS: Wenn ihr Code braucht, sagt mir was ihr wollt!
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
//Alle Einheiten löschen CGame* pGame = CMain::Instance().GetCurrentGameState<CGame>(); for(UINT y = 0; y < pGame->m_iGridHeight; ++y) { for(UINT x = 0; x < pGame->m_iGridWidth; ++x) { for(ogUtilsIterator<CDivision*> i = m_pppDivisions[y][x].Begin(); i.NotEndOfList(); ++i) { //Einheit dieses Sektors löschen og2DVector vPos = og2DVector(static_cast<float>(x), static_cast<float>(y)); ogEMS::Instance().SendOneMessage(this, OTCEM_DIVISIONDESTROYED, &i, &vPos); } } OG_SAFE_DELETE_ARRAY(m_pppDivisions[y]); } OG_SAFE_DELETE_ARRAY(m_pppDivisions); //Alle Buildings löschen for(ogUtilsIterator<CBuilding*> iterator = m_pBuildings.Begin(); iterator.NotEndOfList(); ++iterator) { ogEMS::Instance().SendOneMessage(this, OTCEM_BUILDINGDESTROYED, &iterator); } |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
bool BuildingDestroyed(ogUtilsIterator<CBuilding*>* iterator) { //Aus EntityManager löschen ogEMS::Instance().DeleteObject(**iterator); //Instanz selbst löschen OG_SAFE_DELETE(iterator->m_pCurrent->Data); //Aus GebäudeListe entfernen m_pBuildings.Remove(iterator); return true; } bool DivisionDestroyed(ogUtilsIterator<CDivision*>* it, const UINT x, const UINT y) { //Aus EntityManager löschen ogEMS::Instance().DeleteObject(**it); //Instanz selbst löschen OG_SAFE_DELETE(it->m_pCurrent->Data); //Aus der "richtigen" Liste löschen m_pppDivisions[y][x].Remove(it); return true; } |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
bool Remove(ogUtilsIterator<T>* it) { ogUtilsListEntry<T>* pTemp = m_pFirst; ogUtilsListEntry<T>* pLast = NULL; for(UINT i = 0; i < m_iSize; ++i) { if(it->m_pCurrent == pTemp) { if(pLast) pLast->pNext = pTemp->pNext; else m_pFirst = pTemp->pNext; if(pTemp == m_pLast) m_pLast = pLast; it->m_pNextOne = pTemp->pNext; it->m_pCurrent = NULL; //Delete it! OG_SAFE_DELETE(pTemp); --m_iSize; return true; } pLast = pTemp; pTemp = pTemp->pNext; } return false; } |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 |
template <typename T> class ogUtilsIterator; template <typename T> struct ogUtilsListEntry { ogUtilsListEntry<T>* pNext; T Data; }; template <typename T> class ogUtilsList { private: ogUtilsListEntry<T>* m_pFirst; ogUtilsListEntry<T>* m_pLast; UINT m_iSize; public: ogUtilsList() : m_iSize(0), m_pFirst(NULL), m_pLast(NULL) {} ~ogUtilsList() {Clear();} ogUtilsListEntry<T>* Begin() {return m_pFirst;} ogUtilsListEntry<T>* End() {return m_pLast;} UINT GetSize() {return m_iSize;} //-------------------------------------------------------------------------// bool Insert(T& Data) { if(m_iSize <= 0) m_pFirst = m_pLast = new ogUtilsListEntry<T>; else { m_pLast->pNext = new ogUtilsListEntry<T>; m_pLast = m_pLast->pNext; } m_pLast->pNext = NULL; m_pLast->Data = Data; ++m_iSize; return true; } bool Remove(T& Data) { ogUtilsListEntry<T>* pTemp = m_pFirst; ogUtilsListEntry<T>* pLast = NULL; for(UINT i = 0; i < m_iSize; ++i) { if(::memcmp(&(pTemp->Data), &Data, sizeof(T)) == 0) { if(pLast) pLast->pNext = pTemp->pNext; else m_pFirst = pTemp->pNext; if(pTemp == m_pLast) m_pLast = pLast; //Delete it! OG_SAFE_DELETE(pTemp); --m_iSize; return true; } pLast = pTemp; pTemp = pTemp->pNext; } return false; } bool Remove(ogUtilsIterator<T>* it) { ogUtilsListEntry<T>* pTemp = m_pFirst; ogUtilsListEntry<T>* pLast = NULL; for(UINT i = 0; i < m_iSize; ++i) { if(it->m_pCurrent == pTemp) { if(pLast) pLast->pNext = pTemp->pNext; else m_pFirst = pTemp->pNext; if(pTemp == m_pLast) m_pLast = pLast; it->m_pNextOne = pTemp->pNext; it->m_pCurrent = NULL; //Delete it! OG_SAFE_DELETE(pTemp); --m_iSize; return true; } pLast = pTemp; pTemp = pTemp->pNext; } return false; } bool Clear() { for(UINT i = 0; i < m_iSize; ++i) { ogUtilsListEntry<T>* pTemp = m_pFirst; m_pFirst = m_pFirst->pNext; OG_SAFE_DELETE(pTemp); } m_iSize = 0; m_pFirst = NULL; m_pLast = NULL; return true; } }; template <typename T> class ogUtilsIterator { public: ogUtilsListEntry<T>* m_pCurrent; //Wird verwendet, um während eines Schleifendurchgangs auch etwas aus der Liste löschen zu können //Hier wird dann gespeichert, auf welchen Eintrag der Iterator beim nächsten ++ springen soll ogUtilsListEntry<T>* m_pNextOne; ogUtilsIterator() : m_pCurrent(NULL) {} ogUtilsIterator(ogUtilsListEntry<T>* pStart) : m_pCurrent(pStart) {} ~ogUtilsIterator() {} bool EndOfList() {return m_pCurrent == NULL;} bool NotEndOfList() {return m_pCurrent != NULL;} void SetData(T NewData) {if(m_pCurrent) m_pCurrent->Data = NewData;} //Operatoren ogUtilsIterator<T>& operator ++ () {if(m_pCurrent) m_pCurrent = m_pCurrent->pNext; else {m_pCurrent = m_pNextOne; m_pNextOne = NULL;} return *this;} ogUtilsIterator<T>& operator ++ (int) {ogUtilsIterator<T> OldIt = *this; if(m_pCurrent) m_pCurrent = m_pCurrent->pNext; else {m_pCurrent = m_pNextOne; m_pNextOne = NULL;} return OldIt;} ogUtilsIterator<T>& operator () (ogUtilsListEntry<T>* pStart) {m_pCurrent = pStart; return *this;} ogUtilsIterator<T>& operator = (ogUtilsListEntry<T>* pStart) {m_pCurrent = pStart; return *this;} bool operator == (const ogUtilsListEntry<T>* pEntry) {return m_pCurrent == pEntry;} bool operator != (const ogUtilsListEntry<T>* pEntry) {return m_pCurrent != pEntry;} T* operator -> () {return &(m_pCurrent->Data);} T operator * () {return m_pCurrent->Data;} }; |
Zitat von »"David_pb"«
P.S.: Wann kapiert ihr endlich das man einen Zeiger vor dem Löschen NICHT auf 0 testen muss... Das ist sicher, der Standard garatiert es! Rolling Eyes
C-/C++-Quelltext |
|
1 2 3 |
int* ptr = 0; delete ptr; // nix passiert delete 0; // genau das gleiche, nix passiert |
Werbeanzeige