Robbie Morrison wrote:
class MyClass { public: MyClass (int& i) // & indicates pass-by-reference : d_int(&i) { } // & is address-of operator ~MyClass() { std::cout << "destroying a MyClass" << std::endl; } private: boost::shared_ptr<int> d_int; // shared pointer FAILS // int* d_int; // raw pointer works };
int main() { int myint(2); // simple integer MyClass myclass(myint); // constructor call
Here's your problem. boost::shared_ptr is designed to manage heap (new/delete) storage, not auto storage. When a shared_ptr's destructor determines that it was the last shared_ptr to a given heap block, it executes 'delete (wrapped pointer)'. So in effect, you've written: int myint(2); // auto int lives on stack delete &2; // trying to delete from heap A far more typical design for MyClass would accept a boost::shared_ptr<int> as the ctor parameter. You'd allocate your int (or whatever) on the heap, immediately capturing it in a shared_ptr and never again referring to it with a plain dumb pointer. (in MyClass): MyClass(boost::shared_ptr<int> i): d_int(i) {} (in main()): MyClass myclass(new int(2)); or boost::shared_ptr<int> myint = new int(2); MyClass myclass(myint);