struct foo
{
	foo( int value = 0 )
	: value( value )
	{	}

	struct proxy
	{	
		friend proxy operator == ( proxy const& lhs, foo const& rhs )
		{
			return lhs.ptr && equal( *lhs.ptr, rhs ) ? lhs : 0; 
		}
		
		operator bool ( void )
		{
			return ptr != 0;
		}

		proxy( foo const* ptr )
		: ptr( ptr )
		{	}
		
		foo const*
			ptr;
	};

	friend proxy operator == ( foo const& lhs, foo const& rhs )
	{
		return proxy( equal( lhs, rhs ) ? &rhs : 0 ); 
	}
	
	friend bool equal( foo const& lhs, foo const& rhs )
	{
		return lhs.value == rhs.value;
	}
	
	int
		value;
};

int main( void )
{
	cout << bool( foo( 1024 ) == foo( 1024 ) == foo( 1024 ) ) << endl;
	cout << bool( foo( 0 ) == foo( 1024 ) == foo( 1024 ) ) << endl;
	cout << bool( foo( 1024 ) == foo( 0 ) == foo( 1024 ) ) << endl;
	cout << bool( foo( 1024 ) == foo( 1024 ) == foo( 0 ) ) << endl;
	return 0;
}

#include <vector>
#include <algorithm>
#include <iostream>

template<class Iterator>
bool AreAllEqual(const Iterator& begin, const Iterator& end)
{
    std::pair<Iterator, Iterator> equalRet = std::equal_range(begin, end, *begin);
    return ((equalRet.first == begin) && (equalRet.second == end));
}

template<class Container>
bool AreAllEqual(const Container& cont)
{
    return AreAllEqual(cont.begin(), cont.end());
}


int main(int argc, char ** argv)
{
  std::vector<int> d;
  d.push_back(9);
  d.push_back(9);
  d.push_back(9);
  d.push_back(9);
  d.push_back(9);
  std::cout << "Container: " << std::boolalpha << AreAllEqual(d) << '\n';
  int* data = &d[0];
  std::cout << "Array: " << AreAllEqual(data, data + d.size()) << '\n';

  d.push_back(10);  
  std::cout << "Container with 10: " << AreAllEqual(d) << std::endl;
  data = &d[0];
  std::cout << "Array with 10: " << AreAllEqual(data, data + d.size()) << '\n';
}

template <class Iter, class Pred>
bool all(Iter from, Iter to, Pred pred);