I was looking at a performance issue, with some code and found that the cost of creating the dynamic heap memory was the significant cost.
It would have been handy to have a class which implemented something like std::vector, but with a *small* buffer of values to use as an alternative piece of memory when the vector size was below a threshold. [...]
template< class T, size_t size>
class temp_vector
{
[[unconstructed]] T _V[size];
size_t m_constructed = 0;
public:
~temp_vector()
{
///// Destroy the array manually.
for( size_t i = 0; i < m_constructed; i++ ){
_V[i].~T();
}
}
}
I'm amazed that nobody has just given you teh codez yet. Here's basically what you should write:
template<class T, size_t Cap>
class fixed_capacity_vector {
alignas(T) char data_[Cap * sizeof(T)];
size_t size_ = 0;
public:
size_t size() const { return size_; }
T *data() { return (T*)data_; }
const T *data() const { return (const T*)data_; }
T& operator[](int i) { return data()[i]; }
const T& operator[](int i) const { return data()[i]; }
T& push_back(const T& value) {
assert(size_ < Cap);
T *p = ::new ((void*)&data()[size_]) T(value);
++size_;
return *p;
}
void pop_back() {
back().~T();
--size_;
}
fixed_capacity_vector(const fixed_capacity_vector& rhs) {
std::uninitialized_copy(rhs.begin(), rhs.end(), data_);
size_ = rhs.size();
}
fixed_capacity_vector& operator=(const fixed_capacity_vector& rhs) {
// left as an exercise for the reader
// also, move semantics left as an exercise for the reader
}
~fixed_capacity_vector() {
while (!empty()) pop_back();
}
};
Notice the Rule of Three/Five here. If you provide a custom destructor, you should also provide custom copy and move operations (or =delete them).
This is also available fully fleshed out in Boost, in the form of boost::static_vector; and there is an active WG21 proposal, P0843, currently targeting the Library Fundamentals v3 TS.
HTH,
Arthur