3. Überladene Funktionspointer?

Überladene Funktionspointer?

  • ?

    ich habe 2 Funktionen

    int test1(int a)

    und

    int test2(double a, double b)

    kann man den gleichen Funktionspointer zuerst auf test1 und später auf test2 setzen und dann die Funktion aufrufen?

    Wenn ja, kann mir das jemand zeigen wie das geht?

    Mich interessiet einfach ob das möglich ist...

    0
  • R

    Würde mich jetzt auch mal interessieren. Den funcpoin auf die jeweilige Funktion mit unterschiedlichen Parametern zu setzen dürfte IMHO nicht gehen...
    Hm, wie wär's ohne Funktionszeiger in der Art:

    int test(char *func, double a, double b){
  if(*func=="test1")
    return test1((int)a);
  else if(*func=="test2")
    return test2(double a, double b);
  else
    return -1;
}

    Hab's jetzt nicht getestet, aber wenn du test(test1, (double)a, b) oder test(test2, a, b) aufrufst, dann dürfte es so eigentlich funktionieren. Du könntest in diesem Fall natürlich auch eine Funktion test(char *func, ...) als Ellipsen-Prototypen mit variabler Parameterliste deklarieren, aber um auf den ursprünglichen Funktionszeiger nochmal zu sprechen zu kommen -- leider keine Ahnung 😮

    0
  • ?

    Habe das hier gemacht - aber das geht nicht

    #include <iostream.h>
    #include <stdlib.h>

    int test1(int a);
    int test2(double a, double b);

    int main()
    {

    int (*ptr)(int a);
    ptr=test1;
    ptr(123);

    int (*ptr)(double b, double b);
    ptr=test2;
    ptr(3.1415,9.876);

    system("PAUSE");
    return 0;
    }

    int test1(int a)
    {
    cout<<a<<endl;
    }

    int test2(double a, double b)
    {
    cout<<a<<endl;
    cout<<b<<endl;
    }

    0
  • T

    Original erstellt von <GOGO>:
    **Habe das hier gemacht - aber das geht nicht
    **

    Die Zeigervariablen haben ja auch denselben Namen und der zweite hat zweimal den Parameter b 🙂

    0
  • R

    Original erstellt von TriPhoenix:
    ... und der zweite hat zweimal den Parameter b 🙂

    Das macht nix, es handelt sich ja dabei nicht um eine Funktionsdefinition, d.h. double b wird ja nicht wirklich auf dem Stack angelegt.

    Hier dein Programm richtig:

    #include <iostream.h>
#include <stdlib.h>

int test1(int a);
int test2(double a, double b);

int main()
{

int (*ptr)(int a);
ptr=test1;
ptr(123);

int (*ptr1)(double b, double b);
ptr1=test2;
ptr1(3.1415,9.876);

return 0;
}

int test1(int a)
{
cout<<a<<endl;
}

int test2(double a, double b)
{
cout<<a<<endl;
cout<<b<<endl;
}

    Um nochmal auf meine variable Liste von oben zu sprechen zu kommen, hier nun ein kleines C-Programm, welches dies realisiert:

    #include <stdio.h>
#include <stdarg.h>

void test1(int a){
    printf("--> In Funktion %s\n", __func__);
    printf("    a = %d\n", a);
}

void test2(double a, double b){
    printf("--> In Funktion %s\n", __func__);
    printf("    a = %g\n", a);
    printf("    b = %g\n", b);
}

void test(char *func, ...){
    int a1;
    double a, b;
    va_list zeiger;

    va_start(zeiger, *func);

    if(func=="test1"){
        a1 = va_arg(zeiger, int);
        test1(a1);
    }
    else if(func=="test2"){
        a = va_arg(zeiger, double);
        b = va_arg(zeiger, double);
        test2(a, b);
    }
    else
        printf("--> Falsche Funktion übergeben: %s\n", func);

    va_end(zeiger);
}

int main(void){
    int a1=123;
    double a=123.4, b=234.0;

    printf( "Variable Funktion aufrufen\n"
        "--------------------------\n");

    test("test1", a1);
    test("test2", a, b);
    test("test3", a1, b, a+b, b+a);

    return 0;
}

    Viel Spass damit...
    Ciao! 😉

    0
  • K
     

    if(func=="test1")

    Es wundert mich wirklich, dass das funktioniert...Ein strcmp(func, "test1") == 0 wäre glaub ich angebrachter !

    0
  • V

    Original erstellt von <GOGO>:
    **kann man den gleichen Funktionspointer zuerst auf test1 und später auf test2 setzen und dann die Funktion aufrufen?
    **

    ja.

    #include <iostream>
using namespace std;

int test1(int a)
{
    return a*a;
}
int test2(int a,int b)
{
    return a*b;
}

int main()
{
    void (*f)()=reinterpret_cast<void(*)()>(&test1);
    cout<<(*reinterpret_cast<int(*)(int)>(f))(4)<<endl;
    f=reinterpret_cast<void(*)()>(&test2);
    cout<<(*reinterpret_cast<int(*)(int,int)>(f))(3,4)<<endl;
    return 0;
}
    0
  • L

    Pfui 😉 Sag wenigstens dazu das es undefiniert ist, oder ist es das nicht?

    0
  • H

    Was soll daran undefiniert sein?

    @volkard: Arbeitest du öfters so, oder wolltest du nur auf die Frage antworten?

    0
  • ?

    @volkard

    Jo das ist super - nur etwas lang... ich habe gehofft man kann dann einfach f() benutzen...

    Gibts vielleicht eine Abkürzung für den Aufruf?

    0
  • L

    könntest um es zu kürzen die reinterpret_cast's durch C-Casts ersetzten, aber schön ist das nicht;)

    0
  • V

    Original erstellt von <GOGO>:
    @volkard
    Gibts vielleicht eine Abkürzung für den Aufruf?

    jo, gibts. aber ich wllte die fürchterlichkeit unterstreichen und werde weder typedefs, templates noch c_casts zur rein optischen verschönerung anbringen.

    0
  • V

    Original erstellt von Helium:
    @volkard: Arbeitest du öfters so, oder wolltest du nur auf die Frage antworten?

    schlimm, daß du mir sowas zutraust. 😉

    0
  • ?

    Hm verdammt - ich suche eine bessere Lösung.

    Wenn die redifinition etwas länger ist - dann ist es OK
    aber ich hätte gerne den gleichen Aufruf wie bei normaler Funktion

    f=###setzte funktionspointer###
    f(4);
    f=###setzte funktionspointer###
    f(3,4);

    das wäre ideal/genial...

    0
  • V

    ich glaub', daß du mehr sprachmittel brauchst. insbesondere template-klassen, die vin einer gemeinsamen basisklasse erben und so ein gerödel. und dann wirste schon was geeigneteres finden als ausgerechnet vollkommen unleserliche funktionspointer.

    0
Anmelden zum Antworten