template <class T, class C> class Proxy
{
public:
	Proxy& operator=(const T& value)
	{
		m_t = value;
		m_c->updated(m_i);
		return this[0];
	}
	Proxy& operator=(const Proxy& p)
	{
		m_t = p.m_t;
		m_c->updated(m_i);
		return this[0];
	}
	Proxy(C* const c, T& t, const unsigned int i) : m_c(c), m_t(t), m_i(i)
	{
	}
	Proxy(const Proxy& p) : m_c(p.m_c), m_t(t), m_i(p.m_i)
	{
	}
	operator T()
	{
		return m_t;
	}
private:
	unsigned int m_i;
	C* m_c;
	T& m_t;
};

template <class T> class MyVec
{
public:
	MyVec(const std::vector<T>& v) :m_v(v)
	{
	}
	const T& operator[](const unsigned int i) const
	{
		return m_v;
	}
	typedef Proxy<T, MyVec<T> > P;
	P operator[](const unsigned int i)
	{
		return P(this, m_v, i);
	}
private:
	friend class P;
	void updated(const unsigned int i)
	{
		OutputDebugString("Stuff written\n");
	}
	std::vector<T> m_v;
};

int
main(const unsigned int argCount, const char* const args[])
{
//	Create and init a vector that is used to set my vector
	std::vector<int> temp;
	temp.push_back(1);
	temp.push_back(2);
	temp.push_back(3);
//	Create test object
	MyVec<int> test(temp);
	int i = test[2];   // Returns 3 as expected
	test[1] = 10;      // Calls the updated method as expected
	test[1] = test[2]; // Calls the updated method as expected
	return 0;
}

// Add
struct Foo
{
	Foo()
	{
	}
	Foo(const int bar, const int a) : m_bar(bar), m_a(a)
	{
	}
	int m_bar;
	int m_a;
};

// Replace
int
main(const unsigned int argCount, const char* const args[])
{
//	Create and init a vector that is used to set my vector
	std::vector<Foo> temp;
	temp.push_back(Foo(1, 0));
	temp.push_back(Foo(2, 1));
	temp.push_back(Foo(3, 2));
//	Create test object
	MyVec<Foo> test(temp);
	Foo i = test[2];       // Works, no problem here
	test[1] = Foo(10, 11); // Still works, calls the updated method
	test[1] = test[2];     // Same as above

	int fooBar = test[2].m_bar; // Don't compile! Obvious since test[2] is of type Proxy, not Foo as the syntax indicates.
	return 0;
}

//	Add to the public section of class Proxy
	const T* operator->()
	{
		return &m_t;
	}

//	Replace in main:
// 	int fooBar = test[2].m_bar;
// 	With:
	int fooBar = test[2]->m_bar; // Now we can read from the Foo object as expected

//	Add to main
	test[2]->m_bar = 77; // Doesn't compile since -> returns a const pointer, if we return a non-const instead, the assignment will compilebut then the change isn't detected, i.e updated is not called.

db_map<std::string, Mp3Info> mp3s(dbConnection, "mp3s");mp3s("Test.mp3") = ....;db_map<std::string, Mp3Info>::iterator it = mp3s.find("Cool.mp3");it->second = .....;db_vector<std::pair<int, float> > stuff(dbConnection, "stuff");stuff.push_back(std::make_pair(5, 10.0f));stuff.push_back(std::make_pair(7, 20.0f));stuff.push_back(std::make_pair(3, 30.0f));std::sort(stuff.begin(), stuff.end());stuff.erase(stuff.begin() + 1);stuff.clear();