Thread: variable array size

Sure, if you know ahead of time the max size your vector will need, you'd ideally want to call v.reserve().

BTW, how can realloc() destroy objects? It doesn't know anything about objects. If it can't expand the current memory, it allocates new memory somewhere else and does a memcpy() from the old location to the new one.
Obviously that could cause some objects to barf if they rely on pointers to themselves and those pointers don't get updated when they were moved...

In any case, I doubt the performance benefit would be noticable in most cases.

Yes, that's exactly what I'd like to use instead of realloc()! But how exactly would you implement exalloc()? Is there a portable way to do it, or would you have to rely on OS API calls?

Originally Posted by CornedBee

There's absolutely no way to implement it aside from implementing the entire malloc family yourself. It needs internal knowledge of the data structures malloc uses.

I think you're right.
I love a challenge, so I tried to implement my own C++ Realloc() (for Windows), but alas I failed... It seemed to be going pretty well until I tried deleting the old memory, since there's no Placement Delete, and no generic way of calling a destructor in a template.
Here's my attempt:

Code:

template <typename T>
T* Realloc( T* ptr, size_t oldSize, size_t newSize )
{
	T* pNew = (T*)HeapReAlloc( GetProcessHeap(),
				   HEAP_REALLOC_IN_PLACE_ONLY,
				   ptr,
				   newSize );
	if ( pNew == NULL )
	{
		cout << "pNew is NULL!" << endl;
		pNew = (T*)HeapAlloc( GetProcessHeap(), 0, newSize );

		if ( pNew == NULL )
		{
			throw std::bad_alloc( "No memory!" );
		}

		for ( size_t i = 0; i < oldSize; ++i )
		{
			new( &pNew[i] ) T( ptr[i] );	// Copy old value to new location.
			delete &ptr[i];			// Destroy old value ???  No Placement delete?
		}

		HeapFree( GetProcessHeap(), 0, ptr );
	}
	else if ( pNew == ptr )
	{
		cout << "pNew == ptr." << endl;
	}
	else
	{
		cout << "pNew != ptr!" << endl;
	}

	return pNew;
}

Originally Posted by CornedBee

t.~T() ought to work for explicit destruction. And I didn't know HeapRealloc had the IN_PLACE_ONLY option.

That's what I tried the first time, but the compiler didn't know what I was talking about.
I think it's literally looking for a destructor named "~T()" if you do that.

Originally Posted by CornedBee

What compiler do you use? What's your exact code? Because that's exactly the syntax used in The C++ Programming Language. (Well, it uses indirect member access, of course.)

I'll try it again when I get home, but it was something like:

Code:

ptr[i].~T();

But T is a typename, so how would the compiler know what ~T() means? Or does it just expand the name like some kind of macro and then figure out if what it expanded to makes sense?

You're right, ~T() does work.
I think before I was doing: ptr[i]->~T();

Now it seems to work fine.
I beefed up the code to act like new if ptr is NULL, and act like delete if newSize is 0.

Code:

template <typename T>
T* Realloc( T*  ptr,
	size_t  oldSize,
	size_t  newSize )
{
	if ( oldSize == newSize )
	{
		return ptr;
	}

	HANDLE hHeap = GetProcessHeap();
	T* pNew = NULL;

	if ( ptr != NULL )	// If no memory yet, go straight to HeapAlloc().
	{
		// Try to expand array.
		pNew = (T*)HeapReAlloc( hHeap,
					HEAP_REALLOC_IN_PLACE_ONLY,
					ptr,
					(newSize * sizeof( T )) );
	}

	if ( pNew == NULL )	// Failed to expand array.
	{
		if ( newSize > 0 )
		{
			// Try to allocate new memory and copy old array to new one.
			pNew = (T*)HeapAlloc( hHeap, 0, (newSize * sizeof( T )) );

			if ( pNew == NULL )	// Not enough memory.
			{
				throw std::bad_alloc( "No memory!" );
			}
		}

		// Copy all old values to new array and call each old elements destructor.
		for ( size_t i = 0; i < oldSize; ++i )
		{
			if ( i < newSize )	// In case user wants to delete or shrink array.
			{
				new( &pNew[i] ) T( ptr[i] );
			}
			ptr[i].~T();
		}

		if ( ptr != NULL )
		{
			HeapFree( hHeap, 0, ptr );	// Release old memory.
		}
	}

	// Fill the rest of the array with default T's.
	for ( size_t i = oldSize; i < newSize; ++i )
	{
		new( &pNew[i] ) T();
	}

	return pNew;
}