如何使用C ++函数指针作为C函数指针/回调的参数

Question

I do know about C++ lambdas or C function pointers, but I don't know how to mix them together. I already found Mixing C++ instance methods with C callback functions , but it does not relies to my needs.

I have a C++ class the include C headers, like these:

extern "C" {
#include <jack/jack.h>
#include <jack/types.h`enter code here`>
#include <jack/ringbuffer.h>
#include <jack/midiport.h>
}
#include <QDialog>
#include <QFile>
#include <QString>
#include "Cliente.h"

class FormQStudio : public QDialog
{
     Q_OBJECT

public:
    explicit FormQStudio(QWidget *parent = nullptr);
    ~FormQStudio();

    void playMIDIFile(QString file) noexcept(false);

    int theCallback(jack_nframes_t nframes, void *arg);
};

The C headers defines some types :

typedef uint32_t         jack_nframes_t;
typedef int  (*JackProcessCallback)(jack_nframes_t nframes, void *arg);

int jack_set_process_callback (jack_client_t *client,
                   JackProcessCallback process_callback,
                   void *arg) JACK_OPTIONAL_WEAK_EXPORT;

The implementaion of my C++ class needs to pass theCallback(jack_nframes_t nframes, void *arg) as a parameter to C function jack_set_process_callback . But I don't know how to do it.

#include "FormQStudio.h"
FormQStudio::FormQStudio(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::FormQStudio)
{
    ui->setupUi(this);
}

void FormQStudio::playMIDIFile(QString file) noexcept(false){
    smf_t *smf = smf_load(file.toUtf8());
    smf_event_t *event;

    Cliente *c = new Cliente("QStudio");
    c->inicializarCliente( 
       /* HOW TO REFERENCE this->processJackCallback as a parameter? */
   );

}
};

The class "Cliente" is this:

extern "C" {
#include <jack/jack.h>
#include <jack/types.h>
#include <jack/ringbuffer.h>
#include <jack/midiport.h>
}

#include <QString>
#include <QMap>

#include "ClientePorta.h"
#include "QStageException.h"

class Cliente
{
public:
    Cliente(QString clientName);

    struct MidiMessage {
        jack_nframes_t  time;
        int     len;    /* Length of MIDI message, in bytes. */
        unsigned char   data[3];
    };


    jack_client_t *getClient();

    void conectar(QString portaOrigem, QString clienteDestino, QString portaDestino) noexcept(false);



    void inicializarCliente(JackProcessCallback callback) noexcept(false);

    void addClientePorta(ClientePorta * cp);

    ClientePorta* getClientePorta(QString nomePorta);

    void sendMIDI(QString outputPortName, jack_nframes_t nframes ) noexcept(false);

private:
    QString clientName;
    QString inputPortName;
    QString outputPortName;
    QMap<QString,ClientePorta*> portas;
    jack_client_t   *jackClient = NULL;

};

The Cliente.cpp is:

#include "Cliente.h"
#include <QDebug>

Cliente::Cliente(QString clientName)
{
    this->clientName = clientName;
}

void Cliente::inicializarCliente(JackProcessCallback callback) noexcept(false){
    jackClient = jack_client_open(clientName.toUtf8().data(), JackNoStartServer, NULL);

    int err = jack_set_process_callback(jackClient, callback , this);
}
};

I'm ommiting the rest of the implementation since it is not relevant. I'm also not asking about lib jack. The focus is how to pass a C++ function as parameter to a C callback as show above.

Answer 1

Pay attention to the fact that the last parameter to jack_set_process_callback () is a void * , and it gets passed through to the callback function.

This is a common design pattern with C libraries to make them usable with C++.

What you are going to do is pass this of the object whose method you wish to invoke, as a callback, as the void * with the callback pointer to an extern "C" linkage wrapper function that takes the void * , then reinterpret_cast s it back to a class instance pointer, and then invokes its method, something like:

extern "C" {

int fwd_callback(jack_nframes_t nframes, void *arg)
{
    FormQStudio *p=reintrerpret_cast<FormQStudio *>(arg);

    return p->theCallback(nframes);
}

};

// ...

FormQStudio *some_object;

// ...

jack_set_process_callback(client, fwd_callback, reinterpret_cast<void *>(some_object));

Of course, it's on you to make sure that the some_object still exist and is a valid object, when the callback gets invoked.

Answer 2

FormQStudio::theCallback is not a function. It's a non-static member function, which means that it can only be called through an object of type FormQStudio , a pointer to which is passed as this to the function.

C doesn't know anything about C++ classes or class members. So it's not capable of calling such a function.

Moreover, the & operator applied to FormQStudio::theCallback produces a "pointer-to-member-function" (PMF), which is not at all the same thing as a pointer to a function. (That's probably why you're seeing compiler errors, although it's hard to know exactly what you tried from the code sample in your question.) So even C++ programs couldn't use that as a stand-alone callback, although they could use the .* / ->* syntax to invoke it with a provided class intance object reference/pointer.. (Note: these days it's better to use std::invoke rather than the rather obscure operators.)

If it turns out that FormQStudio::theCallback doesn't actually use this at all, then make it static . Then you can take its address and use that as a function pointer. (Although I think it's not guaranteed that C and C++ functions have the same calling conventions, so it's conceivable that you could still have problems passing it to a C function expecting a callback.)