[c++]puntatori a funzione

[giuseppe500]

ciao.
Ho il seguente problema trovato in un esempio di codice :

dichiarazione nel file stesso della funzione, io ho messo questa dichiarazione nel file .h con tutte le altre dichiarazioni.
void DisplayChannels(KFbxNode* pNode, KFbxAnimLayer* pAnimLayer, 
                     void (*DisplayCurve) (KFCurve *pCurve), 
                     void (*DisplayListCurve) (KFCurve *pCurve, KFbxProperty* pProperty), 
                     bool isSwitcher);

impl.
void DisplayChannels(KFbxNode* pNode, KFbxAnimLayer* pAnimLayer, void (*DisplayCurve) (KFCurve *pCurve), void (*DisplayListCurve) (KFCurve *pCurve, KFbxProperty* pProperty), bool isSwitcher)
{
    KFbxAnimCurve* lAnimCurve = NULL;

    // Display general curves.
    if (!isSwitcher)
    {
        lAnimCurve = pNode->LclTranslation.GetCurve<KFbxAnimCurve>(pAnimLayer, KFCURVENODE_T_X);
        if (lAnimCurve)
        {
            printf("        TX\n");
            DisplayCurve(lAnimCurve->GetKFCurve());
        }
        lAnimCurve = pNode->LclTranslation.GetCurve<KFbxAnimCurve>(pAnimLayer, KFCURVENODE_T_Y);
        if (lAnimCurve)
.
.
.

le due funzioni usate come parametri nella funzione sono(DisplayCurveKeys e, DisplayListCurveKeys.
Quello che non ho capito è come si passano le funzioni per parametro.

void CFbxAnimation::DisplayCurveKeys(KFCurve *pCurve)
{
    static char* interpolation[] = { "?", "constant", "linear", "cubic"};
    static char* constantMode[] =  { "?", "Standard", "Next" };
    static char* cubicMode[] =     { "?", "Auto", "Auto break", "Tcb", "User", "Break", "User break" };
    static char* tangentWVMode[] = { "?", "None", "Right", "Next left" };

    KTime   lKeyTime;
    float   lKeyValue;
    char    lTimeString[256];
    KString lOutputString;
    int     lCount;

    int lKeyCount = pCurve->KeyGetCount();

    for(lCount = 0; lCount < lKeyCount; lCount++)
    {
        lKeyValue = static_cast<float>(pCurve->KeyGetValue(lCount));
        lKeyTime  = pCurve->KeyGetTime(lCount);

        lOutputString = "            Key Time: ";
        lOutputString += lKeyTime.GetTimeString(lTimeString);
        lOutputString += ".... Key Value: ";
        lOutputString += lKeyValue;
        /*lOutputString += " [ ";
        lOutputString += interpolation[ InterpolationFlagToIndex(pCurve->KeyGetInterpolation(lCount)) ];
        if ((pCurve->KeyGetInterpolation(lCount)&KFCURVE_INTERPOLATION_CONSTANT) == KFCURVE_INTERPOLATION_CONSTANT)
        {
            lOutputString += " | ";
            lOutputString += constantMode[ ConstantmodeFlagToIndex(pCurve->KeyGetConstantMode(lCount)) ];
        }
        else if ((pCurve->KeyGetInterpolation(lCount)&KFCURVE_INTERPOLATION_CUBIC) == KFCURVE_INTERPOLATION_CUBIC)
        {
            lOutputString += " | ";
            lOutputString += cubicMode[ TangentmodeFlagToIndex(pCurve->KeyGetTangeantMode(lCount)) ];
            lOutputString += " | ";
            lOutputString += tangentWVMode[ TangentweightFlagToIndex(pCurve->KeyGetTangeantWeightMode(lCount)) ];
            lOutputString += " | ";
            lOutputString += tangentWVMode[ TangentVelocityFlagToIndex(pCurve->KeyGetTangeantVelocityMode(lCount)) ];
        }
        lOutputString += " ]";*/
        lOutputString += "\n";
        printf (lOutputString);
    }
}

void CFbxAnimation::DisplayListCurveKeys(KFCurve *pCurve, KFbxProperty* pProperty)
{
    KTime   lKeyTime;
    int     lKeyValue;
    char    lTimeString[256];
    KString lListValue;
    KString lOutputString;
    int     lCount;

    int lKeyCount = pCurve->KeyGetCount();

    for(lCount = 0; lCount < lKeyCount; lCount++)
    {
        lKeyValue = static_cast<int>(pCurve->KeyGetValue(lCount));
        lKeyTime  = pCurve->KeyGetTime(lCount);

        lOutputString = "            Key Time: ";
        lOutputString += lKeyTime.GetTimeString(lTimeString);
        lOutputString += ".... Key Value: ";
        lOutputString += lKeyValue;
        lOutputString += " (";
        lOutputString += pProperty->GetEnumValue(lKeyValue);
        lOutputString += ")";

        lOutputString += "\n";
        printf (lOutputString);
    }
}

mi da questi due errori
Error 1 error C3867: 'CFbxAnimation:isplayCurveKeys': function call missing argument list; use '&CFbxAnimation:isplayCurveKeys' to create a pointer to member c:\programmazione\old2\old\wild magic 4\geometrictools\wildmagic4\samplegraphics\materia ltextures\fbxanimation.cpp 292

Error 2 error C3867: 'CFbxAnimation:isplayListCurveKeys': function call missing argument list; use '&CFbxAnimation:isplayListCurveKeys' to create a pointer to member c:\programmazione\old2\old\wild magic 4\geometrictools\wildmagic4\samplegraphics\materia ltextures\fbxanimation.cpp 292



1)che utilità da questo tipo di gestione dei parametri con puntatore a funzione e i puntatorii a funzione in generale?
2)come posso convertire e rendere compilabile utilizzando le dichiarazioni nel .h anzichè nello stesso cpp?
grazie.

[MacApp]

Originariamente inviato da giuseppe500

le due funzioni usate come parametri nella funzione sono(DisplayCurveKeys e, DisplayListCurveKeys.

sono static o no?

[giuseppe500]

no , non sono statice , ma vengono dichiarate all' intestazione del file .cpp cosi:

#include <fbxsdk.h>

#include <stdio.h>

#include "DisplayCommon.h"

#include <fbxfilesdk/fbxfilesdk_nsuse.h>

void DisplayAnimation(KFbxAnimStack* pAnimStack, KFbxNode* pNode, bool isSwitcher = false);
void DisplayAnimation(KFbxAnimLayer* pAnimLayer, KFbxNode* pNode, bool isSwitcher = false);
void DisplayChannels(KFbxNode* pNode, KFbxAnimLayer* pAnimLayer, 
                     void (*DisplayCurve) (KFCurve *pCurve), 
                     void (*DisplayListCurve) (KFCurve *pCurve, KFbxProperty* pProperty), 
                     bool isSwitcher);
void DisplayCurveKeys(KFCurve *pCurve);
void DisplayCurveDefault(KFCurve *pCurve);
void DisplayListCurveKeys(KFCurve *pCurve, KFbxProperty* pProperty);
void DisplayListCurveDefault(KFCurve *pCurve, KFbxProperty* pProperty);

cosa vuol dire dichiarare le funzioni in quella posizione e non nel .h? a che differenze si va incontro?
Grazie.

[MacApp]

Scusa... pensavo che stessi cercando di passare dei metodi..
Nel tuo codice non vedo dove e come venga invocata la DisplayChannels.

Che una cosa sia scritta in un .h o no... non fa nessuna differenza. In genere si scrive nei .h quello che si prevede possa essere utile venire incluso da altri file.. se non lo si ritiene utile, lo si puo' scrivere direttamente nel sorgente.

[giuseppe500]

scusa , qui passa ai 2 parametri puntatore a funzione: le funzioni:
DisplayCurveKeys, DisplayListCurveKeys

non il puntatore pero' , le funzioni , non capisco , pero' funziona tutto correttamente.

void DisplayAnimation(KFbxAnimLayer* pAnimLayer, KFbxNode* pNode, bool isSwitcher)
{
    int lModelCount;
    KString lOutputString;

    lOutputString = "     Node Name: ";
    lOutputString += pNode->GetName();
    lOutputString += "\n\n";
    printf(lOutputString);


    DisplayChannels(pNode, pAnimLayer, DisplayCurveKeys, DisplayListCurveKeys, isSwitcher);
    printf ("\n");

    for(lModelCount = 0; lModelCount < pNode->GetChildCount(); lModelCount++)
    {
        DisplayAnimation(pAnimLayer, pNode->GetChild(lModelCount), isSwitcher);
    }
}

[giuseppe500]

un altra cosa:
io ho lo scope nelle mie funzioni della classe:
CFbxAnimation::
, mentre lui non usa nessuno scope , puo' essere un problema?

[MacApp]

Originariamente inviato da giuseppe500
un altra cosa:
io ho lo scope nelle mie funzioni della classe:
CFbxAnimation::
, mentre lui non usa nessuno scope , puo' essere un problema?

Sì, dipende dal contesto.

[giuseppe500]

scusa mcapp, ma come faccio a passare un puntatore a una funzione con lo scope a differenza di quello che fa lui senza scope?
grazie.

[MacApp]

Originariamente inviato da giuseppe500
scusa mcapp, ma come faccio a passare un puntatore a una funzione con lo scope a differenza di quello che fa lui senza scope?
grazie.

Non si capisce bene quale sia il tuo problema: riduci ai minimi termini il problema e posta il codice problemi.
Ad intuito mi sembra che tu stia cercando di passargli un puntatore ad un metodo di un oggetto, quando invece la funzione vuole un metodo static di classe o una funzione.