Complicated class function...?

What I'm trying to achieve is command system. For example if i type in into command /setWeather Rain. It would run that function from weather and it would start raining in my game.

Here are a couple of ideas:
1) Rename your objects to make your intent clearer. For instance, rename the interface CommandC to be something similar to "ICommandReceiver", and rename "run" to "receiveCommand".
2) Next, make "run"/"receiveCommand" take an array of strings -- the arguments ("apple", "orange") passed into the command from the string ("/sample apple orange").
3) Have a central object that parses a command string into command+arguments, and dispatching it to the appropriate object.

Here's an example:

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <sstream>
#include <iterator>
#include <algorithm>

using namespace std;

class ICommandReceiver {
public:
virtual ~ICommandReceiver() {
}

public:
virtual bool receiveCommand( const vector<string>& args ) = 0;
};

class SampleObject : public ICommandReceiver {
public:
bool receiveCommand( const vector<string>& args ) {
cout << "SampleObject::receiveCommand, arguments are: {";
if ( args.size() ) {
copy( args.begin(), args.end()-1, ostream_iterator<string>( cout, ", " ) );
cout << args.back();
}
cout << "}\n";

return true;
}
};

class Console {
public:
bool executeCommand( string command ) {
istringstream ss( command );
string obj;

if ( !(ss >> obj) )
return false;

map<string,ICommandReceiver*>::iterator itr = mRegisteredObjects.find( obj );
if ( itr == mRegisteredObjects.end() )
return false; // Not found

vector<string> args = vector<string>( istream_iterator<string>(ss), istream_iterator<string>() );
return itr->second->receiveCommand( args );
}

void registerObject( string name, ICommandReceiver* obj ){
mRegisteredObjects[name] = obj;
}

public:
map<string, ICommandReceiver*> mRegisteredObjects;
};

int main() {
Console con;
SampleObject obj;

con.registerObject( "Test", &obj );
con.executeCommand( "Test apple orange banana" );
}


Thanks so much I'm trying to work out your sample code atm

Just thought I'd be a little more explicit about the concept that you're trying to use (not that any of the information fastcall22 gave was wrong).

Google, or research information about virtual functions and pure virtual functions. That is what you're after.

Functions that are marked as being virtual in a class declaration are able to be overridden by derived classes using that same name for one of their functions. The idea is used in polymorphism.


class Base
{
public:
virtual void VAnnounce();
};
class Derived : public Base
{
public:
virtual void VAnnounce();
}


In the above example Derived is free (but does not have too) to define it's own function that will be used when an instance is accessed through a pointer to Base.


Base *pBase = new Derived();
pBase->VAnnounce();


The extension, pure virtual functions, indicate that there is no definition in the base class and that any derived types must write there own definition.


class IBase
{
public:
virtual void VAnnounce() = 0;
};
class Derived : public Base
{
public:
virtual void VAnnounce();
}


Derived must contain a definition for VAnnounce.

Functions that contain pure virtual function become interfaces and it isn't possible to declare objects of that type.

Hopefully that explains what you're after in slightly more detail about the general topic.

Thanks, I actually got it working in very similar way