#include<iostream.h>

class testClass{

private:
	void show1(int num) {cout << "show1 num=" << num << endl;}
	void show2(int num) {cout << "show2 num=" << num << endl;}
	void show3(int num) {cout << "show3 num=" << num << endl;}
	void (*fptr[3])(int);
public:
	void show(int which, int num);
	testClass();
};

void testClass::show(int which, int num){

	*fptr[which-1](int num);        // Hier wird einen Fehler angemeldet.
}

testClass::testClass(){

	fptr[0] = &show1;               // Hier sind anderen drei Fehler.
	fptr[1] = &show2;
	fptr[2] = &show3;
}

void main(){

	int select, num;
	testClass myObject;

	cout << "select a fuction (1-3) and a number." << endl;
	cin >> select;
	cin >> num;
	myObject.show(select, num);

	cin >> select;    // wait for the result
}

Wechle Fehler habe ich macht?
Danke schoen!

Besser uebersichtlicher und damit einfacher handhabbar sind virtuelle Methoden ...

nich getestet :

Class IFunction
{
public:
    virtual ~IFunction(){}
    virtual void Process(int num) = 0;    
};

class Show1 : public IFunction
{
public: 
    Show1(){}
    virtual ~Show1(){}
    virtual void Process(int num)
    {
        std::cout << "show1 num=" << num << std::endl;
    }
};

class Show2 : public IFunction
{
public: 
    Show2(){}
    virtual ~Show2(){}
    virtual void Process(int num)
    {
        std::cout << "show2 num=" << num << std::endl;
    }
};

class Show3 : public IFunction
{
public: 
    Show3(){}
    virtual ~Show3(){}
    virtual void Process(int num)
    {
        std::cout << "show3 num=" << num << std::endl;
    }
};

class TestClass
{
public:
    TestClass():mMapper(3,NULL) // gleich mit 3 Null Zeigern initialisieren 
    {
        // funktionen im Mapper belegen 
        mMapper[0] = &mshow1;
        mMapper[1] = &mshow2;
        mMapper[2] = &mshow3;
    }
    virtual ~TestClass()
    {
    }
    void show(int which, int num)
    {
        // unabgesichert ! 
        mMapper[which]->Process(num);
    }
private:
    // vir erzeugen die Objecte mal statisch 
    // koennte man auch besser dynamisch ueber ne objectfabrik machen .... 
    Show1 mshow1;
    Show2 mshow2;
    Show2 mshow3;

    // und natuerlich der Mapper als vector
    // spaeter koennt man das noch dynamischer ausbauen mit ner map etc ... 
    // vector statt statischem Array, weil das initialisieren besser geht ... und die Allokation-geschwindigkeit beim einmaligen anlegen nich so die rolle spielt
    std::vector<IFunction *> mMapper;
};

Faend ich besser lesbar und vor allem auch erweiterbarer ...
Gibt aber auch viele C-Juengerer in der C++ Welt, denen an der stelle der Aufwand, die 4 zusaetzlichen klassen zu schreiben, zu hoch ist ...
Im binaercode duerfter der aufwand relativ gleich sein ...

Ciao ...