#include <vector>

struct Foo
{
	int PublicVariable;
};

struct Model
{
	std::vector<Foo> TestVectorMember;
};


int main()
{
	Model model;
	model.TestVectorMember.resize( 2u );
	for (unsigned int i = 0u; i < 2u; ++i)
	{
		Foo& fooRef1 = model.TestVectorMember[i];
		fooRef1-> // <-- "corrected" from '.' to '->'
	}

	std::vector<Foo> testVectorLocal( 2u );
	for (unsigned int i = 0u; i < 2u; ++i)
	{
		Foo& fooRef2 = testVectorLocal[i];
		fooRef2-> // <-- "corrected" from '.' to '->'
	}

	Foo testArray[2];
	for (unsigned int i = 0u; i < 2u; ++i)
	{
		Foo& fooRef3 = testArray[i];
		fooRef3-> // <-- "corrected" from '.' to '->'
	}

	Foo& fooRef4 = testArray[0];
	fooRef4-> // <-- "corrected" from '.' to '->'

	Foo testInstanceLocal;
	for (unsigned int i = 0u; i < 2u; ++i)
	{
		Foo& fooRef5 = testInstanceLocal;
		fooRef5. // <-- kept as dot
	}

	return 0;
}

class Foo
{
public:
	int nAge;
	char* lpszName;
	Foo& GetThis() { return *this; }
};

void Bar(Foo& ref)
{
	ref.lpszName = "Andromeda"; // . was left alone
}

void main()
{
	Foo* pFoo = new Foo;
	Foo &myref = pFoo->GetThis(); // . was correctly converted to ->
	myref.nAge = 2; // . was left alone
	pFoo->GetThis().lpszName = "Capricorn"; // first . converted to ->, second left alone
}

// using a const reference
const Foo &foobar = myObject->GetFoo();
foobar.Something(); // I type '.', I get an '->'

// using a const reference as an argument
void SomeMethod( const Foo &foo )
{
     foo.Something(); // Same issue.
}

// calling a method directly from the returned referance
myObject->GetFoo().Something(); // Hitting '.' after GetFoo(), puts an '->'