InsideQC Forums

Code: Select all

#if defined(WIN32) || defined(_WIN32)

namespace dsa {

	/****************************************************************************************************
	stack_array<T> constructs n elements of T type on a given memory buffer at initialization in ctor,
	and destructs these elements in its dtor. It does not allocate or deallocate memory.

	The given memory buffer should be at least sizeof(T)*n bytes.
	T must be default constructible and its dtor should not throw.

	Its main purpose is to simulate T arr[n]; on stack using alloca with n unknown at compile time.
	This allocates the array really fast compared to using dynamic memory allocation from heap.
	*****************************************************************************************************/
	template <typename T>
	class stack_array
	{
	public:
		stack_array(T* p, size_t n) : p_(p), n_(n) { init_elements(); }
		~stack_array() { uninit_elements(n_); }

		// use like T ts[n], ts+i, ts[i] etc.
		operator T* () { return p_; }

		// very limited container like support support.
		size_t size() { return n_; }
		T* begin() { return p_; }
		T* end() { return p_ + n_; }

	private:
		// uninitialize the first n elements in reverse order.
		void uninit_elements(size_t n)
		{
			while (n > 0)
			{
				p_[--n].~T();
			}
		}

		// default construct all elements, or none at exception.
		void init_elements()
		{
			size_t i = 0;
			try
			{
				for (; i < n_; ++i)
				{
					// note: boost::has_trivial_default_constructor avoids unnecessary ctor calls explicitly
					T* pi_ = new (p_ + i) T;
					// if this breaks, initial buffer may not hold n elements for element alignment problems
					assert(pi_ == p_ + i);
				}
			}
			catch (...)
			{	// when T ctor throws
				uninit_elements(i);	// clean up initialized objects.
				throw;	// re-throw the exception.
			}
		}
	private:
		T*       p_;
		size_t   n_;
	};
} // dsa

// allocate from stack a memory buffer that holds n T objects.
// This does not handle the case that _alloca fails. Handling that is platform specific.
#define NEW_ON_STACK(T, n)                static_cast<T*>(_alloca(sizeof(T)* (n)))

// auxilliary macro to be used with stack_array:
//   dsa::stack_array<T> arr(NEW_STACK_ARRAY(T,n));
#define NEW_STACK_ARRAY(T, n)             NEW_ON_STACK(T, (n)), (n)

// convenience macro to create a stack_array object arr of n T type objects on stack.
#define DYNAMIC_STACK_ARRAY(T, arr, n)    dsa::stack_array<T> arr(NEW_STACK_ARRAY(T, n))