r3dux.org

#include <iostream>
using std::cout;
using std::endl;
 
class Foo
{
	public:
		// Property
		int number;
 
		// Constructor
		Foo() : number(0)
		{
			cout << "Constructing an object of type Foo..." << endl;
		}
 
		// First overloaded function operator, i.e. we're overloading the operator ()
		void operator()()
		{
			cout << "From our first overloaded () operator, I get the number: " << number << endl;
		}
 
		// Second overloaded function operator
		void operator()(Foo &first, Foo &second)
		{
			if (first.number > second.number)
			{
				cout << "The first number property is greater than the second number property." << endl;
			}
			else
			{
				cout << "The first number property is less than or equal to the second number property." << endl;
			}
		}
};
 
void doNothing(Foo tempFoo)
{
	cout << "I'm not using the overloaded () operator here." << endl;
}
 
int main()
{
	// Create our first test object
	Foo firstObject;
 
	// Make sure it's initialised with the default value specified in the constructor
	cout << "From main, number is: " << firstObject.number << endl;
 
	// Call the doNothing function on our Foo object - doesn't do a lot!
	doNothing(firstObject);
 
	// Anonymous object creation (i.e. invokes the constructor - but we don't keep a named object)
	Foo();
 
	// ***THIS*** is where the overloaded function operator comes in!
	firstObject();
 
	// Create a second test object and specify a value
	Foo secondObject;
	secondObject.number = 5;
 
	// Run our first overloaded function operator again on a different object
	secondObject();
 
	// Run our second overloaded function operator on the first object
	firstObject(firstObject, secondObject);
 
	// Run our second overloaded () operator (function operator) again, but on diff object
	// It doesn't matter which object we run it on - behviour is only dependant on the order
	// in which we supply the object parameters in this case!
	secondObject(firstObject, secondObject);
 
	// Finally, just to prove we can trigger the second path in the 2nd overloaded function operator...
	secondObject(secondObject, firstObject);
 
	return 0;
}

#include <iostream>
#include <iterator>
#include <algorithm>
 
class countfrom {
	private:
		int &count;
	public:
	  countfrom(int &n) : count(n) {}
	  int operator()() { return count++; }
};
 
int main() {
	int state(10);
	std::generate_n(std::ostream_iterator<int>(std::cout, "\n"), 11, countfrom(state));
	return 0;
}