I wrote a variable-length stack allocator for the `vector<>` class in C++ 11. In order to be able to allocate size dynamically at runtime I made use of the non-standard `alloca()` function, which is available in a multitude of C++ implementations, including GCC and Visual Studio.

The purpose of this class is to improve performance of allocation of small arrays on the stack whose size cannot be determined at compile-time while still retaining the helpful features of the `vector<>` class.

    #pragma once

    #include <functional>

	template <typename T>
	class stack_allocator {
		template<typename> friend class stack_allocator;

	public:
		typedef size_t size_type;
		typedef ptrdiff_t difference_type;
		typedef T* pointer;
		typedef const T* const_pointer;
		typedef T& reference;
		typedef const T& const_reference;
		typedef T value_type;

		template<typename T2>
		struct rebind {
			typedef stack_allocator<T2> other;
		};

	private:
		T* ptr;
		size_t currentSize, maxSize;

	public:
		stack_allocator() noexcept :
			ptr(nullptr),
			currentSize(0),
			maxSize(0) {
		}

		stack_allocator(T* buffer, size_t size) noexcept :
			ptr(buffer),
			currentSize(0),
			maxSize(size) {
		}

		template <typename T2>
		explicit stack_allocator(const stack_allocator<T2>& other) noexcept :
			ptr(reinterpret_cast<T*>(other.ptr)),
			currentSize(other.currentSize),
			maxSize(other.maxSize) {
		}

		T* allocate(size_t n, const void* hint = nullptr) {
			T* pointer = ptr + currentSize;
			currentSize += n;
			return pointer;
		}

		void deallocate(T* p, size_t n) {
			currentSize -= n;
		}

		size_t capacity() const noexcept {
			return maxSize;
		}

		size_t max_size() const noexcept {
			return maxSize;
		}

		T* address(T& x) const noexcept {
			return &x;
		}

		const T* address(const T& x) const noexcept {
			return &x;
		}

		T* buffer() const noexcept {
			return ptr;
		}

		template <class T2>
		stack_allocator& operator=(const stack_allocator<T2>& alloc) {
			return *this;
		}

		template <typename... Args>
		void construct(T* p, Args&&... args) {
			new (p) T(args...);
		}

		void destroy(T* p) {
			p->~T();
		}

		template <typename T2>
		bool operator==(const stack_allocator<T2>& other) const noexcept {
			return ptr == other.ptr;
		}

		template <typename T2>
		bool operator!=(const stack_allocator<T2>& other) const noexcept {
			return ptr != other.ptr;
		}
	};

    #define init_stack_vector(Type, Name, Size) std::vector<Type, std::stack_allocator<Type>> Name((std::stack_allocator<Type>(reinterpret_cast<Type*>(alloca(Size * sizeof(Type))), Size))); Name.reserve(Size)

A simple usage example:

    #include <vector>
    #include <string>
    #include "stdio.h"
    #include <iostream>
    #include "stack_allocator.h"

    using namespace std;

    int main() {
	    string input;
	    cout << "How many integers shall we store? ";
	    getline(cin, input);

	    init_stack_vector(int, v, stoi(input));
	    for (int i = v.capacity() - 1; i >= 0; i--)
		    v.push_back(i);
	    for (int i = v.capacity() - 1; i >= 0; i--)
		    printf("%d\n", i);
	    system("pause");
	    return 0;
    }

The `init_stack_vector()` macro cannot be substituted by a template function, as that would risk the function not being inlined in Debug mode, and if it's not inlined, `alloca()` would allocate on its stack and it would be popped immediately returning, causing usage of the pointer returned by `alloca()` to depend on undefined behaviour.

Any thoughts/critique?