C/C++: Probleme mit Funktionspointern

[Matthias S. (da_user)]

Hi,
ich habe da ein Problem beim verwenden von Funktionspointern bei der 
Übergabe bei einer Klasseninitalisierung. Ich habe mich hierbei an den 
zweiten Forenbeitrag in diesem Link gehalten: 
https://www.spieleprogrammierer.de/18-c-cplusplus-csharp-java-und-andere-programmiersprachen/6621-funktionszeiger-funktionen-als-parameter/


Folgendes Szenario:
Ich habe eine Klasse "Class":

namespace Namespace
{
    class Class    
    {
    private:
        void(*FuncPtr)() = NULL;
    public:
        Class()
        {}

        Class(int value, void(*funcPtr)())
        {
            FuncPtr = funcPtr;
        }
    /*****/
    };
}

Die Funktion wird so definiert und die Klasse so initalisiert:

void Funktion()
{ /*****/ }

int foo;

Namespace::Class Klasse;

void setup()
{
    Klasse = Class(foo, void (*Funktion)())  /<<<<Fehler
    /****/
}

Hier tauchen zwei Fehler auf, einer kommt vom Visual Studio, das 
unterkingelt mir das Rückgabe-void mit dem Fehlertext:
"der Ausdruck vor den Klammern des sichtbaren Aufrufs muss einen 
Funktionstyp (pointer-to-) aufweisen"

Der Compiler meldet mir folgenden Fehler:
"void value not ignored as it ought to be"

Wenn ich die void durch int ersetze, und natürlich für in die Funktion 
ein return 0 einbaue, erhalte ich vom Visual Studio die gleiche 
Fehlermeldung, der Compiler meldet allerdings:
"expression cannot be used as a function".

Was mache ich hier falsch?

[Sven B. (scummos)]

Nimm std::function, die Syntax ist viel weniger wirr.

[Daniel V. (danvet)]

Matthias S. schrieb:

>

> void Funktion()
> { /*****/ }
> 
> int foo;
> 
> Namespace::Class Klasse;
> 
> void setup()
> {
>     Klasse = Class(foo, void (*Funktion)())  /<<<<Fehler
>     /****/
> }

>
> Was mache ich hier falsch?

Reicht es nicht, einfach den Funktionsnamen anzugeben?

void setup()
{
    Klasse = Class(foo, Funktion)
    /****/
}

[DPA (Gast)]

Ungetestet:

void Funktion(){}
Namespace::Class* Klasse;
void setup(){
    Klasse = new Class(foo, &Funktion);
}

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Matthias S. schrieb:

Hallo Matthias,

>         void(*FuncPtr)() = NULL;

diese Art der Initialisierung gibt es erst seit C++11.


>     Klasse = Class(foo, void (*Funktion)())  /<<<<Fehler

Du must hier zwischen der Deklaration eines Parameters von Typen: "Ist 
Funktion, die keine Argumente nimmt und nix zurück gibt" und der 
Übergabe eins konkreten Werts beim Aufruf unterscheiden. Der erst 
Parameter ist von Typen int. Dort übergibst Du doch auch einfach einen 
int:

    Klasse = Class(foo, Funktion);

[Matthias S. (da_user)]

Och man... manchmal sieht man den Baum vor lauter Bäumen nicht. Und wenn 
man sich mit vorherigen Experimenten auch noch selbst eine Falle 
stellt...
Das wars, danke!

[Tom (Gast)]

Wenn man Funktionspointer konsequent weg-typedeft, dann steht die 
ekelhafte Syntax nur an einer Stelle und der Rest des Programms bleibt 
davon verschont:

class Class
{
public:
    typedef void (*tVoidFunc)();
    Class(int value, tVoidFunc fp) : m_fp(fp) { }
private:
    tVoidFunc m_fp;
};

void myfunc(){}

int main(){
    Class c(23, myfunc);
    return 0;
}

[Sven B. (scummos)]

Wenn man std::function benutzt, braucht man sie nicht mal an einer 
Stelle :D

[nocheinGast (Gast)]

Tom schrieb:
> Wenn man Funktionspointer konsequent weg-typedeft [...]

Dafür werden mich jetzt ggf. Leute schimpfen, aber man kann das auch so 
machen:

typedef void Funktion();

void f() {}

Funktion* fp = f;

[Vincent H. (vinci)]

Die leserlichste Form einer Typdefinition eines Funktionszeigers bekommt 
man imho via

using VoidFp = auto (*)() -> void;

[Sven B. (scummos)]

using VoidFp = std::function<>;

[Rolf M. (rmagnus)]

Vincent H. schrieb:
> Die leserlichste Form einer Typdefinition eines Funktionszeigers bekommt
> man imho via
> using VoidFp = auto (*)() -> void;

Ist das ironisch gemein? Da ist ja gegenüber einer normalen 
Funktionsdefinition alles verdreht.

[Vincent H. (vinci)]

Rolf M. schrieb:
> Vincent H. schrieb:
>> Die leserlichste Form einer Typdefinition eines Funktionszeigers bekommt
>> man imho via
>> using VoidFp = auto (*)() -> void;
>
> Ist das ironisch gemein? Da ist ja gegenüber einer normalen
> Funktionsdefinition alles verdreht.

Nein das mein ich ernst. Ich schreib gern C++ Code aber der Purist in 
mir sieht Rückgabewerte lieber am Ende einer Definition.

// Go
func add(x int, y int) int {
  return x + y
}

// Rust
fn five() -> i32 {
    5
}

[Carl D. (jcw2)]

Vincent H. schrieb:
> Nein das mein ich ernst. Ich schreib gern C++ Code aber der Purist in
> mir sieht Rückgabewerte lieber am Ende einer Definition.
>
>

> // Go
> func add(x int, y int) int {
>   return x + y
> }
> 
> // Rust
> fn five() -> i32 {
>     5
> }
>

dann man es doch ;-)
Ist in (modernem) C++ eben eine Form das zu schreiben

[Dr. Sommer (Gast)]

Matthias S. schrieb:
> Namespace::Class Klasse;
>
> void setup()
> {
>     Klasse = Class(foo, void (*Funktion)())

Dir ist klar, dass du hier erst eine "leere" Instanz anlegst, und dann 
in der main() eine temporäre zweite Instanz, und die über die erste 
kopierst? Einfacher (und effizienter) wäre so:

Namespace::Class Klasse (foo, Funktion);
int main () {
...
}

So brauchst du auch den Standard Konstruktor nicht mehr.
Die Instanz einer Klasse nennt man übrigens Objekt, und nicht Klasse...

Matthias S. schrieb:
> void(*FuncPtr)() = NULL;

NULL ist veraltet, bitte nullptr nutzen...

[Matthias S. (da_user)]

Tom schrieb:
> Wenn man Funktionspointer konsequent weg-typedeft, dann steht die
> ekelhafte Syntax nur an einer Stelle und der Rest des Programms bleibt
> davon verschont:
>

> class Class
> {
> public:
>     typedef void (*tVoidFunc)();
>     Class(int value, tVoidFunc fp) : m_fp(fp) { }
> private:
>     tVoidFunc m_fp;
> };
> 
> void myfunc(){}
> 
> int main(){
>     Class c(23, myfunc);
>     return 0;
> }
>

Danke.
Jetzt habe ich verstanden, warum bei der Verwendung von typdef immer von 
"Vereinfachung" gesprochen wird.

[Rolf M. (rmagnus)]

Matthias S. schrieb:
> Jetzt habe ich verstanden, warum bei der Verwendung von typdef immer von
> "Vereinfachung" gesprochen wird.

Typisches Beispiel dafür ist die Standard-C-Funktion signal():

void (*signal(int signum, void (*handler)(int)))(int);

Vereinfacht:

     typedef void (*sighandler_t)(int);
       sighandler_t signal(int signum, sighandler_t handler);