C++ String and Pointers Manipulation

Suppose I have this data structure in C++ :

struct Stash {
  int size;      // Size of each space
  int quantity;  // Number of storage spaces
  int next;      // Next empty space
   // Dynamically allocated array of bytes:
  unsigned char* storage;
  // Functions!
  void initialize(int size);
  void cleanup();
  int add(const void* element);
  void* fetch(int index);
  int count();
  void inflate(int increase);
};///:~

void Stash::initialize(int sz) {
  size = sz;
  quantity = 0;
  storage = 0;
  next = 0;
}

int Stash::add(const void* element) {
  if(next >= quantity) // Enough space left?
    inflate(increment);
  // Copy element into storage,
  // starting at next empty space:
  int startBytes = next * size;
  unsigned char* e = (unsigned char*)element;
  for(int i = 0; i < size; i++){
     storage[(startBytes + i)] = e[i];

  }

  next++;
  return(next - 1); // Index number
}

void* Stash::fetch(int index) {
  // Check index boundaries:
  assert(0 <= index);
  if(index >= next)
    return 0; // To indicate the end
  // Produce pointer to desired element:
  int value = (index*size);
  return &(storage[value]);
}

int Stash::count() {
  return next; // Number of elements in CStash
}

void Stash::inflate(int increase) {
  assert(increase > 0);
  int newQuantity = quantity + increase;
  int newBytes = newQuantity * size;
  int oldBytes = quantity * size;
  unsigned char* b = new unsigned char[newBytes];
  for(int i = 0; i < oldBytes; i++)
    b[i] = storage[i]; // Copy old to new
  delete []storage; // Old storage
  storage = b; // Point to new memory
  quantity = newQuantity;
}

void Stash::cleanup() {
  if(storage != 0) {
    cout << "freeing storage" << endl;
    delete []storage;
  }
}  ///:~

Suppose now I use the data structure to memorize strings in this way :

int main(){


    Stash* st1 = new Stash;

    st1->initialize(sizeof(string));
    string s1 = "This is a GOOD morning";
    st1->add(&s1);


    string s2 = "This is a BAD morning";
    st1->add(&s2);


    string* s3;
    s3 = static_cast<string*> (st1->fetch(0));
    cout << *s3 << endl;

    string* s3;
    s3 = static_cast<string*> (st1->fetch(1));
    cout << *s3 << endl;

    st1->cleanup();

    delete st1;

    return 0;
}

It Works!!! This is the output:

This is a GOOD morning
This is a BAD morning

But in this other way:

int main(){


    Stash* st1 = new Stash;

    st1->initialize(sizeof(string));
    string s1 = "This is a GOOD morning";
    st1->add(&s1);

    s1 = "This is a BAD morning";
    st1->add(&s1);

    string* s3;
    s3 = static_cast<string*> (st1->fetch(0));
    cout << *s3 << endl;

    string* s4;
    s4 = static_cast<string*> (st1->fetch(1));
    cout << *s4 << endl;

    st1->cleanup();

    delete st1;

    return 0;
}

It doesn't work. This is the output:

This is a BAD morning
This is a BAD morning

So, what happened in the machine when I try to use the same reference? I have tried with other datatypes and it works well.