You cannot have any parameters to operator ->. It's just a function that returns the next pointer to apply the right hand side of the expression on.

myClass x;
x->setAge(25);

What this does (when correctly implemented, that is) is call myClass::operator->(void) that returns a pointer to an object of a different type, and the setAge member function of that object is called. If the object returned has its operator -> overloaded, then the operator is called again, and again, and so on, until you get to an object that doesn't have it overloaded.

What it appears to me that you want to do; adding functions of a class dynamically, is not possible.

I'd argue that it is possible but it takes a rethink. This is basically just local remote procedure call (command pattern locally) and has many uses. With the addition of function, bind and tuple in C++11, the concept is possible but the conventions need to be modified. I can't include all the code here, it takes forever (and it's tricky template stuff I'm sure to get wrong the first couple writings) to write out, but the idea's are viable.

First change: don't use -> and replace it with (). I.e. x->setAge( 25 ); becomes x( setAge, 25 );. Given this is a "dynamic" member, it makes sense that it would be a command style pattern instead of a de-reference pattern. In order to make local members conform, you have to register them in the same manner as external functions.

Your 'registered' function will have something like the form of:

typedef std::function< void ( std::tuple& ) > RegisteredFunction_t;

You have to apply a composite bind to build the function object passed into the registration though, that's pretty complicated unfortunately and I'd probably make a hash of any example, but it is possible and I've done it in some complicated code. (Though I was using Boost function/bind at the time.)

Finally, given the name of the function you end up with a map of names to function objects which will process the tuples. You can make a reference object to stand in for the name or just use the string, i.e. "obj( refFunc, ...args )" or "obj( "AStringName", ... args )".

Why I know this is possible is that I had a really complicated XML system where some of the sections were completely under plugin control and this is basically how it worked.

This is a horribly high level overview but it is possible. Explore function, bind and tuple and you should be able to figure it all out. (NOTE: bind will require composite binds which are really confusing at first, stick with it though, they make so many things really easy.)