deallocate of allocator in C++

Question

I've defined a class template Vec which holds a sequence of T like vector:

template <typename T> class Vec {
    public:
        size_t size() const { return first_free - elements; }
        size_t capacity() const { return cap - elements; }
        T *begin() const { return elements; }
        T *end() const { return first_free; }
        void resize(const size_t); // something wrong in this function
        ... 
    private:
        allocator<T> alloc; //allocates the elements
        T *elements; // pointer to the first element in the array
        T *first_free; // pointer to the first free element in the array
        T *cap; // pointer to one past the end of the array
        ...
}; 

when my code calls this function, the programm will crash,

template <typename T> void Vec<T>::resize(const size_t newcap)
{
    // this part goes well
    if(newcap > capacity()) {
        auto newdata = alloc.allocate(newcap);
        auto dest = newdata;
        auto orig = elements;
        for(size_t i = 0; i != size(); ++i) 
            alloc.construct(dest++, std::move(*orig++));
        elements = newdata;
        first_free = dest;
        cap = elements + newcap;
    }
    // crash happens in the following two parts
    else if(size() <= newcap && newcap < capacity()) { // deallocate the redundant memory where no element exists
       alloc.deallocate(elements + newcap, capacity() - newcap); // this line causes crash 
       cap = elements + newcap; 
    }   
    else if(size() < newcap) { // destroy the elements and deallocate the memory
        for(auto p = first_free; p != elements + newcap; /*empty*/)
            alloc.destroy(--p);
        alloc.deallocate(elements + newcap, capacity() - newcap); // this line causes crash 
        first_free = cap = elements + newcap;
    }
}

calling code:

Vec<string> v{"aaa", "bbb", "ccc"}; // size() == 3, capacity == 3
v.resize(2); // to resize v to size() == 2, capacity == 2

I think I've made a right deallocate calling and correct pointer arithmetic. Thank you.

Answer 1

alloc.deallocate(elements + newcap, capacity() - newcap);

You can't do that. Allocator are all or nothing: you either deallocate the entire block that was allocated or you leave it alone.

To shrink your allocated memory, do the same allocate-and-copy dance that you do when the new size is greater than the current capacity, but allocate the new smaller size.

Incidentally, the part marked //this part goes well has a major problem: it never deallocates the old memory block.