Object Creation using Smart Pointers and Map

#include <iostream>
#include <tchar.h>
#include <string>

#include "SmartMap.h"

using namespace std;

class Foo
{
	friend SmartMap<string,Foo>;
	// private constructor to ensure that Foo objects can only be created by
	// CleverMap<string,Foo> (notice it's a friend) which enforces 
	// smart pointers to avoid memory leaks 
	Foo(string n):name(n){}
public:
	string name;
};


int _tmain(int argc, _TCHAR* argv[])
{
	SmartMap<string,Foo> fooMaker;

	Observer<Foo> fooObserver;
	{
		Retain<Foo> foo1 = fooMaker["id 001"];	// creates a Foo with key "id 001"
		Retain<Foo> foo2 = fooMaker["id 001"];	// doesn't need to create a Foo as it already exists
		Retain<Foo> foo3 = foo2;				// now we have 3 references to the same object

		cout << foo1.get()->name << " has " << foo1.use_count() << " references" << endl;
		// foo1, foo2, foo3 all have a reference count of 3 as for all intents and purposes it is the same object
		// output: "id 001 has 3 references"

		fooObserver = foo1;
		cout << fooObserver._Get()->name << " has " << fooObserver.use_count() << " references" << endl;
		// notice that we still have 3 references even though we've added an observer
		// that's because the observer has no baring on the reference count
		// output: "id 001 has 3 references"

		{
			Retain<Foo> foobar = fooMaker["id 999"];
			fooObserver = foobar;
			cout << fooObserver._Get()->name << " has " << fooObserver.use_count() << " references" << endl;
			// the foo observer is now observing foobar and reports that it has only 1 reference
			// output: "id 999 has 1 references"

			foobar = foo1;
			cout << "fooObserver expired? " << std::boolalpha << fooObserver.expired() << " and has " << fooObserver.use_count() << " references" << endl;
			// fooObserver is still pointing to a Foo with the key "id 999" but foobar is now pointing to "id 001",
			// so Foo with the key "id 999" has gone out of scope and deleted itself (expired). Remember, just because fooObserver is
			// still pointing to it doesn't mean it is still in scope, because observers have no baring on the reference count
			// output: "fooObserver expired? yes and has 0 references"

			fooObserver = foo1;
			cout << fooObserver._Get()->name << " has " << fooObserver.use_count() << " references" << endl;
			// since foobar has been added to the Foo with the key "id 001" we now have a reference count of 4
			// output: "id 001 has 4 references"
		}	


		fooObserver = foo1;
		cout << fooObserver._Get()->name << " has " << fooObserver.use_count() << " references" << endl;
		// foobar is now out of scope so the Foo with the key "id 001" has dropped 1 reference
		// output: "id 001 has 3 references"
	}
	

	cout << "fooObserver expired? " << std::boolalpha << fooObserver.expired() << " and has " << fooObserver.use_count() << " references" << endl;
	// all the foos have gone out of scope so they all have deleted themselves
	// output: "fooObserver expired? yes and has 0 references"

	char dummy[32];
	gets(dummy);
	return 0;
}