Boost shared_ptr on class object - c++

Question

Say I have the following code:
controller.hpp
#include "testing.hpp"
#include <boost/shared_ptr.hpp>
class controller
{
public:
controller(void);
void test_func (void);
boost::shared_ptr <testing> _testing;
}
controller.cpp
#include "controller.hpp"
controller::controller() {
boost::shared_ptr <testing> _testing (new testing);
std::cout << _testing->test_bool << std::endl;
}
void controller::test_func (void) {
// how to use _testing object?
std::cout << _testing->test_bool << std::endl;
return;
}
int main (void) {
controller _controller; // constructor called
test_func();
return 0;
}
testing.hpp
class testing
{
public:
bool test_bool = true;
}
Am I using a shared_ptr properly here for a class member? Multiple functions in class controller need to use the _testing object, and I don't want the testing classes' constructor / deconstructor to be called every time the pointer goes out of scope. Maybe this cant' be avoided, I'm starting to realize.

Answer 1

The testing object get constructed in controller constructor and destructed when it go out of the scope.
Just:
int main (void) {
controller _controller; // constructor called
_controller.test_func();
// destructor of controller called, because it go out of scope,
// so testing destructor is called too because, there is no more
// shared_ptr pointing to it!
}
[EDITED] To match question owner edits

Answer 2

I've taken the liberty of rewriting your code to demonstrate a usage of a shared pointer. Pretty typically it is used so an object can be in two places at once, moved around, and destruction is automatic.
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
class testing
{
public:
std::string str;
testing( const char* in ) : str( in ) { }
};
typedef boost::shared_ptr <testing> SP_testing;
class controller
{
public:
controller( const char* in );
void test_func ( );
SP_testing _testing;
};
controller::controller( const char* in )
:_testing( boost::make_shared< testing >( in ) )
{
std::cout << "controller constructor: \"" << _testing->str << '\"' << std::endl;
}
void controller::test_func (void) {
std::cout << "test_func: \"" << _testing->str << "\" - cnt: " << _testing.use_count( ) << std::endl;
}
int main (void)
{
//yet to be used shared pointer
SP_testing outsider;
{
//this will create an instance of testing.
controller _controller( "this is a test" ); // constructor called, prints
outsider= _controller._testing; //assign shared pointer
_controller.test_func( ); // test called, prints usage count.
}//leaving scope, _controller will be destroyed but the _testing it created will not
std::cout << "outsider: \"" << outsider->str << "\" - cnt: " << outsider.use_count( ) << std::endl;
//now testing will get destroyed.
return 0;
}
Above, 'outsider' took a pointer to controller::_testing. At test_func they both have a pointer to the same object. Even though controller create the testing object it does not get destroyed when controller gets destroyed. Very handy when these kind of situations arise. This code can be pasted into one .cpp file. Thanks to #Dan Mašek for the heads up on make_shared