Stocker des pointeurs de fonction

Celui-ci utilise un simple pointeur de fonction, mais que si je veux stocker que de pointeur de fonction? Dans ce cas, quelle serait la déclaration de la variable?

#include <iostream>
#include <vector>

using namespace std;

double operation(double (*functocall)(double), double wsum);
double get_unipolar(double);
double get_bipolar(double);

int main()
{
    double k = operation(get_bipolar, 2); //how to store get_bipolar?
    cout << k;
    return 0;
}
double operation(double (*functocall)(double), double wsum)
{
    double g = (*functocall)(wsum);
    return g;
}
double get_unipolar(double wsum)
{
    double threshold = 3;
    if (wsum > threshold)
        return threshold;
    else
        return threshold;
}
double get_bipolar(double wsum)
{
    double threshold = 4;
    if (wsum > threshold)
        return threshold;
    else
        return threshold;
}

OriginalL'auteur Ismail Marmoush | 2010-02-10

c++function-pointers

7

Vous code est presque déjà fait, vous semblez appeler de façon incorrecte, il devrait être tout simplement
```
double operation(double (*functocall)(double), double wsum)
{
    double g;
    g = functocall(wsum);
    return g;
}
```
Si vous voulez avoir une variable, il est déclaré dans la même manière
```
double (*functocall2)(double) = get_bipolar;
```
ou quand déjà déclaré
```
functocall2 = get_bipolar;
```
vous donne une variable appelée functocall2 qui est de référencement get_bipolar, en l'appelant simplement en faisant
```
functocall2(mydouble);
```
ou de le transmettre à l'opération par
```
operation(functocall2, wsum);
```
yesssss c'est ce que je voulais .. exactement ce que je voulais sauver le get_bipolar dans une variable .. si je peux utiliser cette variable à nouveau dans un autre lieu, ou de faire un tableau de
j'ai déclaré la functocall2 dans le fichier d'en-tête , comment l'attribuer à un fichier cpp ????????????
Simplement functocall2 = get_bipolar; tout comme toute autre affectation.

OriginalL'auteur falstro
5

Vous déjà (presque) dans votre code:
```
double (*functocall)(double) = &get_bipolar;
```
Ceci définit un pointeur de fonction nommée functocall qui points à get_bipolar.

ne devrait-elle pas être simplement ... = get_bipolar; sans &?
comme ceci? double (*functocall)(double) = &get_bipolar; k=opération(???,2); // alors quoi mettre ici ??
En utilisant le & est certainement permis et généralement préféré par les personnes dans le "explicite est mieux qu'implicite" camp
êtes-vous sûr de cela, il se sent comme les fonctions sont, de par leur définition même des pointeurs (pour le code) déjà.
Peut-être que vous devriez mettre des crochets dans les #includes ?

OriginalL'auteur Péter Török

typedef double (*func_t)(double); 
func_t to_be_used = get_bipolar

OriginalL'auteur pierrotlefou

2
```
typedef double (*PtrFunc)(double); 

PtrFunc ptrBipolar = get_bipolar;


OR


typedef double (Func)(double); 

Func *ptrBipolar = get_bipolar;
```
qui jamais vous êtes à l'aise à utiliser.

Mais quand typedefing des types de fonction, j'avais le nom de "Func" au lieu de "PtrFunc".
oui certainement ,vous avez raison. Je suis en train de corriger.

OriginalL'auteur Ashish
1

Ont un look à la fonction "boost", c'est un en-tête seule bibliothèque qui remet de l'ordre dans les choses un peu (à mon humble avis):
http://www.boost.org/doc/libs/1_42_0/doc/html/function.html
```
typedef boost::function<double (double)> func_t;
func_t to_be_used = &get_bipolar;
```
(NB: les différentes syntaxe requise pour VC6)

Dans le cas des OP cas cela va ajouter une surcharge pour chaque appel sans aucun des avantages supplémentaires
Il y a des avantages et des inconvénients à la fonction "boost". La surcharge est susceptible d'être négligeable dans le cas des OP de cas d'utilisation, l'avantage est dans le code plus propre et une plus grande évolutivité. Semblait utile de mentionner dans un forum comme celui-ci afin que les lecteurs puissent voir ce qui est disponible.

OriginalL'auteur Patrick
0
```
double (*foo)(double);
```
où foo est le nom de la variable.

OriginalL'auteur Vebjorn Ljosa

Vous devriez envisager d'utiliser un typedef:

 typedef double (*MyFunc)(double);
 MyFunc ptr_func = &get_bipolar;
 (*ptr_func)(0.0);


double operation(MyFunc functocall, double wsum)
{
    double g;
    g = (*functocall)(wsum);
    return g;
}

Mai je recommande également le modèle d'identité astuce:

template<class T>
class Id
{
    typedef T type;
};

Id<double(double)>::type * ptr_func = &get_bipolar;
MyFunc func = &get_bipolar;
(*ptr_func)(0.0);


double operation(Id<double(double)>::type * functocall, double wsum)
{
    double g;
    g = (*functocall)(wsum);
    return g;
}

OriginalL'auteur Manuel

Vous devez vous connecter pour publier un commentaire.