~Array<I>() {
if(ptr) {
delete[] ptr;
ptr=0;
}
}
//Backslashes removed for legibility.
#define setPtr(_size) {
assert(static_cast<bool>(_size>0),"New array size negative.",true)
if(ptr)
delete[] ptr;
if(_size) {
ptr=new I[_size];
assert(ptr,"Memory allocation error.",true)
} else {
ptr=0;
}
}
~Array<I>() { if(ptr) { delete[] ptr; //Right here; I step over this line in the //Array<char> instance of this class and //there goes that same error message. ptr=0; } }operator delete:00404CC0 push ebp00404CC1 mov ebp,esp00404CC3 push ecx00404CC4 push ebx00404CC5 push esi00404CC6 push edi00404CC7 cmp dword ptr [pUserData],000404CCB jne operator delete+0Fh (00404ccf)00404CCD jmp operator delete+83h (00404d43)00404CCF mov eax,dword ptr [pUserData]00404CD2 sub eax,20h00404CD5 mov dword ptr [pHead],eax00404CD8 mov ecx,dword ptr [pHead]00404CDB mov edx,dword ptr [ecx+14h]00404CDE and edx,0FFFFh00404CE4 cmp edx,400404CE7 je operator delete+6Ah (00404d2a)00404CE9 mov eax,dword ptr [pHead]00404CEC cmp dword ptr [eax+14h],100404CF0 je operator delete+6Ah (00404d2a)00404CF2 mov ecx,dword ptr [pHead]00404CF5 mov edx,dword ptr [ecx+14h]00404CF8 and edx,0FFFFh00404CFE cmp edx,200404D01 je operator delete+6Ah (00404d2a)00404D03 mov eax,dword ptr [pHead]00404D06 cmp dword ptr [eax+14h],300404D0A je operator delete+6Ah (00404d2a)00404D0C push offset string "_BLOCK_TYPE_IS_VALID(pHead->;;nBlo"... (004284a0)00404D11 push 000404D13 push 2Fh00404D15 push offset string "dbgdel.cpp" (00428494)00404D1A push 200404D1C call _CrtDbgReport (00408f60)Quote:Original post by Evil Steve
Also, what's wrong with an inline function instead of that macro?
Quote:The problem is that you're almost certainly overrunning the bounds of your array. The only reason it's caught at the delete[] call is because that's the only til the CRT touches the memory, and so the first time it notices it's trashed.
//POST: If this array is shrunk, its contents are lost. void setSize(int _size) { assert(static_cast<bool>(_size>=0),"New array size negative.",true) if(size>_size) { if(ptr) delete[] ptr; ptr=new I[_size]; assert(ptr,"Memory allocation error.",true) size=_size; } else if(size<_size) { I* old=ptr; ptr=new I[_size]; assert(ptr,"Memory allocation error.",true) if(old) { for(int i=0;i<size;++i) //Go up to old size to copy existing elements. ptr=old; delete[] old; } size=_size; } //Else do nothing because the size is the same. }//Overlying functions omitted.setSize(_size);for(int i=0;i<size;++i) ptr=arr;setSize(other.size);for(int i=0;i<size;++i) ptr=other.ptr;setSize(size+1);ptr[size-1]=add;int temp=size;setSize(size+other.size);for(int i=temp;i<size;++i) ptr=other.ptr;assertIndex()for(int i=index;i<size-1;++i) ptr=ptr[i+1];--size;void setSize(int _size) // _size should be an unsigned int, but I won't break your interface{ assert(static_cast<bool>(_size>=0),"New array size negative.",true) if(size == _size) return; // Nothing to do I* newStorage = new I[_size]; if(ptr && (_size > size)) { // Copy what we can to the new array for(int i=0; i < min(size, _size); ++i) newStorage = ptr; } delete[] ptr; ptr = newStorage; size = _size;}//POST: If this array is shrunk, its contents are lost.void setSize(int _size) { assert(_size >= 0, "New array size negative.", true); assert(ptr); // fix the constructor to make sure it's always initialized to // point to some allocation. if (size == _size) { return; } // nothing to do. I* old = ptr; ptr = new I[_size]; std::copy(old, // at old + std::min(size, _size), // until ptr); // to delete[] old; size = _size;}// concatenate two objects?int temp=size;setSize(size+other.size);for(int i=temp;i<size;++i) ptr=other.ptr; // ERROR! wrong indices into 'other'!Quote:8) Don't do this stuff yourself, except for practice. Use std::vector. Incidentally, it has a smarter way of handling the memory allocations, to avoid having to re-allocate for every appended element.
void realloc(int _length) { ++_length; //Leave trailing null for cout. assert(_length>0,"New primitive array length negative.") delete[] ptr; ptr=new I[_length]; length=_length; } //POST: All elements at end of array are lost if array is shrunk. void setSize(int _size) { assert(_size>=0,"New array size negative.") if(size==_size) return; int i=0; if(length>=_size) { //#### I'm maintaining extra space, so // I just increase the size. i=size=_size; //Set counter, i, here to clear all elements after. } else { I* old=ptr; if(old) { int oldSize=size; ptr=0; //Zero-out to prevent deletion of 'old' during realloc. //Either double the length or //match the needed space. realloc(__max(_size,length+length)); for(;i<oldSize;++i) ptr=old; delete[] old; } else { realloc(_size); } size=_size; } for(;i<length;++i) ptr=0; } };
