Frage zu Function Point...

cn1h

Hi, ich moechte ein klein Program schreiben, um die Erkennis von Function Point zu ueben. Folgend ist mein Code:

#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!

phlox81

Schau mal in die FAQ.
Funktionspointer zeigen auf Funktionen,
Funktionen innerhalb von Klassen jedoch nennt man Methoden.
Da ist dann ein kleiner Workaround nötig, um diese dann
über Methodenzeiger aufzurufen.

RHBaum

und ausserdem, funktionspointer unter C++ sind mit bedacht zu verwenden ...

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 ...

cn1h

Danke schoen!