With your first chunk of code, you use the _initializer list_ to _construct_ the class variables. So in this case, a _copy_ of `notHighlighted` is passed to the constructor of `buttonText` during the construction of the instance of `buttonObj`. The values are not _assigned_, they're _copied_. For trivial objects like SDL_Color, it's not really an issue.

In your second code chunk, you get stuff deleted because the _copy constructor_ of `buttonText` is called to construct `buttonText` from `notHighlighted`. Once the copy is done (i.e. once `buttonText` is constructed from `notHightlighted`), the copy (which is notHighlighted) is deleted (i.e. the destructor is called). If `notHighlighted` had references to stuff allocated by SDL, and the destructor has SDL deallocate that stuff, and the copy constructor of `text` did not make proper clones of these items, the references pointed by `buttonText` will be no longer valid. 
 
To avoid that, you have a couple of options:

* Make sure that `text` creates appropriate copies of referenced SDL objects when copy-constructed.
* Use raw pointers and make sure you know when you should delete the text. (This is doable but requires great care to avoid memory leaks.)

 string textContent;
 text* buttonText;
 text* highlighted_buttonText;

 //Constructor
 buttonObj(string tex, text* notHighlighted, text* highlighted) : 
 textContent( tex ), 
 buttonBase( img ), 
 buttonText( notHighlighted ), 
 highlighted_buttonBase( hI ), 
 highlighted_buttonText( highlighted )
 {}
 
* Use shared pointers so that the object is properly deleted when no longer in use. (This is one of the favoured methods.)

 string textContent;
 std::shared_ptr<text> buttonText;
 std::shared_ptr<text> highlighted_buttonText;

 //Constructor
 buttonObj(string tex, std::shared_ptr<text> notHighlighted, std::shared_ptr<text> highlighted) : 
 textContent( tex ), 
 buttonBase( img ), 
 buttonText( notHighlighted ), 
 highlighted_buttonBase( hI ), 
 highlighted_buttonText( highlighted )
 {}
 
---

> I see that the texts are constructed and then destructed

Instead of just spamming the console with "text::ctor" and "text::dtor" when constructed and destructed, also output the address of the object (i.e. the `this` pointer) you'll see a bit more _what object_ is actually being constructed and destructed.

And as always, even if outputing data to the console is one of the best way to debug, a good step-by-step debugger is very nice to have and use in such cases.