What does it mean when it give the error EXC_BAD_ACCESS when it comes to this code?

The aim of this product is to create a class that behaves as a vector of strings. My removeAt function and insertAt function are are not working as planned.

removeAt is to behave as such: member function that removes the element at the input position from the vector, shifting elements backwards as appropriate;

insertAt is to behave as such: member function that inserts an element at the input position, moving elements (including the element previously there) forward and when this would push the vector size above the capacity then all the elements should be copied over to a new dynamic array of twice the former capacity before this process;

I would love to be able to use both functions accordingly.

Here is my header file:

#ifndef VectorString_h
#define VectorString_h
#include <iostream>
#include <memory>

class VectorString{
private:
    std::size_t sz;
    std::size_t cap;
    std::unique_ptr<std::string[]> dynamic;
public:
    VectorString();
    VectorString(std::size_t value);
    VectorString(std::size_t value, const std::string& STR_INITIATE);
    VectorString(const VectorString& COPY_C);
    VectorString(VectorString&& MOVE_C);
    std::size_t size () const;
    std::size_t capacity() const;
    void push_back(const std::string& str_input);
    void pop_back();
    void removeAt(std::size_t rem);
    void insertAt(std::size_t ins, const std::string& str_inputA);
    std::string& at(std::size_t at);
    //void make_new();

};

VectorString::VectorString() : sz(0), cap(1), dynamic(new std::string[cap]()){

}
VectorString::VectorString(std::size_t value) : sz (value), cap(value*2), dynamic(new std::string[cap]())
{


}
VectorString::VectorString(std::size_t value, const std::string& STR_INITIATE) : sz(value), cap(value*2), dynamic(new std::string[cap]()){


    for(int i=0; i < value; i++){

        dynamic[i] = STR_INITIATE;

    }

}
VectorString::VectorString(const VectorString& COPY_C): sz(COPY_C.size()), cap(COPY_C.capacity())
{
    std::unique_ptr<std::string[]> DUPLICATE(new std::string[cap]);

    for (int i = 0; i < sz ; i++)
    {
        DUPLICATE[i] = dynamic [i];
    }

}

VectorString::VectorString(VectorString&& MOVE_C) : sz(MOVE_C.size()), cap(MOVE_C.capacity()){

    dynamic.reset(MOVE_C.dynamic.release());


};

std::size_t VectorString::size()const{
    return sz;
}
std::size_t VectorString::capacity() const{
    return cap;
}



void VectorString::push_back(const std::string& str_input){



    if(sz >= cap){
        std::unique_ptr<std::string[]> DUPLICATE(new std::string[cap * 2]);
        for (int i = 0; i < sz ; i++){
            DUPLICATE[i] = dynamic [i];
            swap(DUPLICATE, dynamic);

        }
        cap*=2;
        dynamic.reset(DUPLICATE.release());
    }
    dynamic[sz] = str_input;
    sz++;


}
void VectorString::pop_back()
{
    std::unique_ptr<std::string[]> DUPLICATE(new std::string[cap * 2]);
    for (int i = 0; i < sz ; i++)
    {
        DUPLICATE[i] = dynamic [i];
    }
    sz++;
    dynamic.reset(DUPLICATE.release());


};
void VectorString::removeAt(std::size_t rem){
    dynamic[rem] = "\b";

    /* std::unique_ptr<std::string[]> DUPLICATE(new std::string[cap * 2]);
     for (int i = 0; i < rem ; i++)
     {
     DUPLICATE[i] = dynamic [i];
     }
     for(size_t j = rem + 1; j<sz; j++){
     DUPLICATE[j-1]=dynamic[j];
     }
     sz--;
     dynamic.reset(DUPLICATE.release());*/


};
void VectorString::insertAt(std::size_t ins, const std::string& str_inputA)
{
    if(sz>=cap){
        std::unique_ptr<std::string[]> NEW_POINTER(new std::string[cap]);
        for (size_t i = 0; i<sz; i++)
        {
            NEW_POINTER[i] = dynamic[i];
            swap(NEW_POINTER, dynamic);
            //cap*=2;
        }
        dynamic.reset(NEW_POINTER.release());

    }

    dynamic[ins] = str_inputA;


    /* if(sz == cap){
     std::unique_ptr<std::string[]> DUPLICATE(new std::string[cap * 2]);
     for (size_t i = 0; i < sz ; i++){
     DUPLICATE[i] = dynamic [i];
     swap(DUPLICATE, dynamic);
     cap*=2;
     dynamic.reset(DUPLICATE.release());
     }
     }
     std::unique_ptr<std::string[]> DUPLICATE(new std::string[cap * 2]);
     for (int i = 0; i < ins ; i++)
     {
     DUPLICATE[i] = dynamic [i];
     }
     DUPLICATE[ins] = str_inputA;
     for(size_t j = ins ; j<sz + 1; j++){
     DUPLICATE[j+1]=dynamic[j];
     }
     sz--;
     dynamic.reset(DUPLICATE.release());*/
};
std::string& VectorString::at(std::size_t at){



    return dynamic[at];

};




#endif /* VectorString_h */

/*void VectorString::make_new()
 {
 std::unique_ptr<std::string[]>cool(new std::string[cap*2]{});
 for(std::size_t i = 0; i<sz;i++)
 cool[i] = dynamic[i];
 swap(cool, dynamic);
 cap*=2;

 }*/

And here is my cpp:

#include <iostream>
#include "VectorString.h"



using namespace std;

VectorString foo(){
    return VectorString(2);
}

int main(){
    VectorString vs;
    cout<<"vs stats: "<<vs.size()<<" "<<vs.capacity() <<std::endl;
    vs.push_back("hello");
    cout<<"vs store: "<<vs.at(0)<<std::endl;

    VectorString vs2(foo());
    cout<<"vs2 stats: "<<vs2.size() << " "<<vs2.capacity()<<endl;

    cout<<"vs2 stores: ";
    for (size_t i = 0; i < vs2.size()-1; ++i)
    {

        cout<<vs2.at(i)<<",";
    }
    cout << "\b" <<endl;

    VectorString vs3(3, "beta");
    vs3.pop_back();
    vs3.push_back("delta");
    vs3.push_back("epsilon");
    vs3.at(1) = "gamma";
    vs3.insertAt(0, "alpha");
    vs3.push_back("zeta");
    vs3.push_back("theta");
    vs3.insertAt(vs3.size()-1, "eta");
    cout<<"v3 stats: "<<vs3.size()<<" "<<vs3.capacity()<<endl;
    cout<<"v3 stores: ";

    for(size_t i = 0; i < vs3.size(); i++)
    {
        cout<<vs3.at(i)<<",";
    }
    cout<<"\b";
    cin.get();
    return 0;
}

I am no longer reaching the error but my output is looking something like this:

vs stats: 0 1 vs store: hello vs2 stats: 2 4 vs2 stores: , v3 stats: 8 12 v3 stores: alpha,,beta,,delta,,zeta,eta,

when it is supposed to be:

alpha,beta,gamma,delta,epsilon,zeta,eta,theta

It would seem as if the program is missing some inputs. How do I grab every one of those words?