C Funktionspointer auf sich selbst

[jgdo (Gast)]

Hallo,

ich möchte eine Funktion erstellen, die einen Zeiger auf eine Funktion 
mit gleicher Signatur wie die Funktion selbst zurückgibt. Also so, dass 
man die Funktion mittels

f(bla)(blub)(foo)...

beliebig oft direkt nacheinander aufrufen kann. Ist das in C(++) möglich 
und wenn ja, wie hat der Funktionskopf auszusehen?

- jgdo -

[Frank M. (ukw) (Moderator)]

parse error.

[Karl H. (kbuchegg)]

http://c-faq.com/decl/recurfuncp.html

[Klaus W. (mfgkw)]

Vielleicht mit einem Funktionsobjekt:

#include <iostream>

class MyFO
{
public:
    MyFO &operator()( int a )
    {
        std::cout << "operator()( int a = " << a << " )" << std::endl;
        return *this;
    }
};

int main( int nargs, char **args )
{
    MyFO     myFO;

    myFO( 5 )( 4 )( 42 );
}

Das ergibt:

F:\kw>cl /EHsc t.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 15.00.30729.01 for 80x86
Copyright (C) Microsoft Corporation.  All rights reserved.

t.cpp
Microsoft (R) Incremental Linker Version 9.00.30729.01
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:t.exe
t.obj

F:\kw>t
operator()( int a = 5 )
operator()( int a = 4 )
operator()( int a = 42 )

Von wegen parse error ... :-)

[Simon K. (simon)]

+ 1 auf Abgefahrenheit :-D

[Frank M. (ukw) (Moderator)]

Klaus Wachtler schrieb:
> Von wegen parse error ... :-)

Der parse error war schlichtweg in meinem Kopf: ich habe einfach nicht 
verstanden, was er wollte und wozu das Ganze gut ist. Letzteres weiß ich 
immer noch nicht.

[Klaus W. (mfgkw)]

Frank M. schrieb:
> Letzteres weiß ich immer noch nicht.

ich auch nicht, aber es läuft doch.

[Klaus W. (mfgkw)]

Sein Problem ist in C in der Tat nicht trivial bzw. vielleicht gar nicht 
lösbar, weil man den Typ "Zeiger auf eine Funktion..." in derselben 
Typdefinition noch nicht als Rückgabe der Funktion verwenden kann.

Wie will man dann eine Funktion definieren, die einen Zeiger auf sich 
selbst liefert? So eine leere forward-Deklaration wie bei structs gibt 
es für Funktionen ja nicht.

[Jörg W. (dl8dtl) (Moderator)]

Klaus Wachtler schrieb:
> Von wegen parse error ... :-)

Thema verfehlt.  Im Subject steht "C", nicht "C++".

Aber pervers ist dein Zeugs da schon. ;-)

[jgdo (Gast)]

Danke für die Antworten Leute.

@Karl Heinz Buchegger
Das ist eine Möglichkeit, aber ich wollte die Casts eben vermeiden. 
Schade dass es direkt nicht geht.

@Klaus Wachtler
Ist eine Klasse und keine Funktion.

@alle
mir gings eher um das Prinzip, eine echte Anwendung dafür habe ich 
nicht. Ich habe nur eine Funktion, die mehrmals nacheinander mit 
verschiedenen Parametern aufgerufen wird und ich wollte mal einfach 
etwas Tipparbeit sparen ;)

[Kan a. (Firma: Basta) (kanasta)]

void * Func(...) {
...
return &Func;
}


so vielleicht?

[Kan a. (Firma: Basta) (kanasta)]

int res;

void *Func(int p1) {
  res += p1;
  return &Func;
}

int main(void) {
  res = 0;

  int (*p)(int) = Func(5);
  (*p)(10);

  printf("res=%d", res);
}


Also irgendwie krieg ich das Func(x)(y) nicht hin. Weiß jemand anderes 
weiter?

[Karl H. (kbuchegg)]

Kan asta schrieb:
> int res;
>
> void *Func(int p1) {
>   res += p1;
>   return &Func;
> }

Du hast die Problemstellung noch nicht verstanden

> Also irgendwie krieg ich das Func(x)(y) nicht hin. Weiß jemand anderes
> weiter?

Sieh dir den FAQ Link von weiter oben an. Da sind 2 Lösungsmöglichkeiten 
gegeben. Beide nicht besonders schön.
Das Problem, wie schon weiter oben vermerkt, besteht darin, dass es 
sowas wie eine 'Forward-Deklaration' für Funktionspointer nicht gibt. 
Die würde man aber brauchen, damit man einen Funktionspointer machen 
kann, auf eine Funktion die genau diesen Funktionspointer-Typ liefert.

[Klaus W. (mfgkw)]

  jgdo schrieb:
> @Klaus Wachtler
> Ist eine Klasse und keine Funktion.

Manchen kann man es nie recht machen...

Dann halt als Funktion:

#include <iostream>

class MyFO
{
private:
    MyFO (*m_f)( int a );

public:
    MyFO( MyFO (*f)( int a ) )
        : m_f(f)
    {}

    MyFO operator()( int a )
    {
        return m_f( a );
    }
};

MyFO f( int a )
{
    std::cout << "operator()( int a = " << a << " )" << std::endl;
    return MyFO( f );
}

int main( int nargs, char **args )
{
    f( 5 )( 4 )( 42 );
}

Gleiche Ausgabe wie oben.

[Klaus W. (mfgkw)]

Jörg Wunsch schrieb:
> Thema verfehlt.  Im Subject steht "C", nicht "C++".

nee, Überschrift falsch!
Im OP steht "...C(++)..."

[max (Gast)]

Hm, was spricht dagegen die Parameter in ein Array zu packen und über 
dieses zu Iterieren? Ob es nun besser ist, das Array als ganzes an die 
Funktion zu übergeben oder jeden Parameter einzeln ist dann wieder ein 
anderes Thema. (ersteres ist besser lesbar und sollte auch in 
schnellerem Code resultieren, letzteres ist universeller)

[Karl H. (kbuchegg)]

max schrieb:
> Hm, was spricht dagegen die Parameter in ein Array zu packen und über
> dieses zu Iterieren?


Na, ja. Das ganze war ja bis jetzt nur eine Spielerei :-)

so richtig geil wird das ganze dann, wenn eine Funktion (abhängig vom 
Parameter) nicht sich selbst zurückgibt, sondern einen Pointer auf eine 
ganz andere Funktion. Man kann da dann ein ganzes Netzwerk von 
Funktionsaufrufen hinter der harmlos anmutenden Syntax

   foo(4)(5)(6)(8);

(oder auch

    do {
      f = f(Werte[i++]);
    } while( f );
)

aufbauen, das kein Mensch mehr ohne 5 Liter Kaffee und eine Großpackung 
Baldrian durchschaut :-) Sowas nennt man dann "aktive 
Arbeitsplatzsicherung".

[max (Gast)]

Karl Heinz Buchegger schrieb:
> aufbauen, das kein Mensch mehr ohne 5 Liter Kaffee und eine Großpackung
> Baldrian durchschaut :-) Sowas nennt man dann "aktive
> Arbeitsplatzsicherung".

und der Sieg beim IOCCC sicher ist :)

[Ben j. (scarab)]

Karl Heinz Buchegger schrieb:
> aufbauen, das kein Mensch mehr ohne 5 Liter Kaffee und eine Großpackung
> Baldrian durchschaut :-) Sowas nennt man dann "aktive
> Arbeitsplatzsicherung".

You made my day :D

[Dani Zwirner (Gast)]

So gehts:

#include "stdio.h"

typedef int (*fp)(int);

fp f(int i)
{
  printf("i=%i\n", i);
  return (fp)f;
}

int main(int argc, char ** argv)
{
  f(1)(2);
  return 1;
}

aber leider nur mit zweifachem Aufruf. Beim dreifachen Aufruf

f(1)(2)(3);

meint der gcc error: called object ‘f(1)(2)’ is not a function

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Ihr spinnt :-)))

[Ben j. (scarab)]

kann man nicht einfach mit einem Makro einen Zeiger auf ein Array von 
Parametern übergeben und dann die Funktion einfach mehrmals aufrufen?

sowas wie

#define foo(var) foo_fctn({ (var) })

//oder falls das nicht geht:

#define foo(var)                \
int array[]={ (var) , 0x7FFF }; \
foo_fctn(array);

int foo_fctn(int * array)
{
    int i=0;
    while( array[i] != 0x7FFF )
    {
       res += foo_nocheine( array[i] );
       i++;
    }
    return res;
}

var = foo(1);
var = foo(1,2);
var = foo(1,2,3);
var = foo(1,2,3,4);

(alles nicht getesten, hab auf meinem Laptop keine IDE ^^)

EDIT: nagut, das array wird bei mehrfacher Verwendung des Makros im 
selben Gültigkeitsbereich Probleme machen aber das Prinzip sollte ja 
ersichtlich sein oder?

EDIT2: werden die Kommas Probleme machen? vielleicht Klammern 
"Übergeben" und temporär Klammern als Komma definieren? xD (falls die 
erste Variante nicht funktioniert)

[Mark B. (markbrandis)]

Karl Heinz Buchegger schrieb:
> Sowas nennt man dann "aktive Arbeitsplatzsicherung".

In richtig guten Firmen kriegen die Leute eine Abmahnung, die solchen 
Code verfassen. ;-)

[Klaus W. (mfgkw)]

Wieso?
Das ist nur eine andere Form eines Zustandsautomats - für den wird man 
auch nicht automatisch abgemahnt.

[Stephan (Gast)]

Karl Heinz Buchegger schrieb:
> Sowas nennt man dann "aktive
> Arbeitsplatzsicherung".

Nope, das nennt man Funktionale Programmierung und ist absolut 
faszinierend, wenn man sich für theoretische Informatik interessiert.

[Frank M. (ukw) (Moderator)]

Dani Zwirner schrieb:
> So gehts:
> [...]
> aber leider nur mit zweifachem Aufruf. Beim dreifachen Aufruf
>

> f(1)(2)(3);
>

> meint der gcc error: called object ‘f(1)(2)’ is not a function

  ((fp) (f(1)(2)))(3);

bzw.

  ((fp) ((fp) (f(1)(2)))(3))(4);

usw.

funktionieren. Das sieht aber nicht mehr so schön aus ;-)

[Läubi .. (laeubi)]

Karl Heinz Buchegger schrieb:
> so richtig geil wird das ganze dann, wenn eine Funktion (abhängig vom
> Parameter) nicht sich selbst zurückgibt, sondern einen Pointer auf eine
> ganz andere Funktion [..] das kein Mensch mehr ohne 5 Liter Kaffee und
> eine Großpackung Baldrian durchschaut :-)
> Sowas nennt man dann "aktive Arbeitsplatzsicherung"
Oder Method Chaining/Fluent Interface:
http://en.wikipedia.org/wiki/Method_chaining
http://en.wikipedia.org/wiki/Fluent_interface
Ich nutze das ab und an mal konnte mich aber bisher noch nicht im großen 
Stil dafür erwärmen...

Wird zwar immer im Zusammenhang mit OO genannt, aber wieso sollte man 
das nicht auch mal in C umsetzen? Der arme Compiler...

[Mark B. (markbrandis)]

Klaus Wachtler schrieb:
> Wieso?
> Das ist nur eine andere Form eines Zustandsautomats - für den wird man
> auch nicht automatisch abgemahnt.

Normalerweise sollte es in einer Firma Richtlinien für die Codierung 
geben. Wenn die Firma Wert auf Qualität legt (das tut freilich nicht 
jede), dann sorgt sie auch dafür, dass diese Richtlinien eingehalten 
werden. Solche Tools wie z.B. MISRA C++ Code Checker mögen in der Regel 
"arbeitsplatzsichernden Code" nicht besonders :-)

[Yalu X. (yalu) (Moderator)]

jgdo schrieb:
> ich möchte eine Funktion erstellen, die einen Zeiger auf eine Funktion
> mit gleicher Signatur wie die Funktion selbst zurückgibt.

In Sprachen mit dynamischer Typisierung (z.B. Python) ist das kein
Problem:

def f(x):
  print('f called with', x)
  return f

f(1)(2)(3)(4)

liefert

f called with 1
f called with 2
f called with 3
f called with 4

Viele Sprachen mit statischer Typisierung scheinen aber Probleme zu
haben, den Typ dieser Funktion compiler-intern darzustellen. Auch in
Haskell, wo man das Ausdenken der Funktionssignaturen i.Allg. dem
Compiler überlassen und ganz lapidar

f x = f

schreiben kann, meckert der Compiler:

    Occurs check: cannot construct the infinite type: t1 = t0 -> t1
    In the expression: f
    In an equation for `f': f x = f

Das ist dort aber kein großes Problem, da dieses Konstrukt sowieso nur
für seiteneffektbehaftete Funktionen von Nutzen ist, die es in Haskell
gar nicht gibt.

Läubi .. schrieb:
> Oder Method Chaining/Fluent Interface:

Auch ganz interessant in diesem Zusammenhang:

  http://en.wikipedia.org/wiki/Continuation-passing_style