Запуск нескольких функций с различной структурой аргумента/возврата по одному указателю функции

Мне кажется, что ты пытаешься найти правильный ответ на неправильный вопрос, типичный для проблемы XY. В примере, приведенном в вашем собственном ответе, вы вызываете указатель функции сразу после установки его значения. В этом случае указатель на функцию бесполезен, так как вы можете напрямую вызвать либо read_chars (), либо write_chars().

Очевидно, это просто потому, что этот пример чрезмерно упрощен. В более реалистичном случае использования вы бы установили указатель функции в одной части кода и вызвали его в совершенно другой части. Предположим , что функции и указатель определены следующим образом:

void (*fun_ptr)();

void read_chars(uint8_t address) {
    printf("address of array is 0x%.2x\n", address);
}

void write_chars(uint8_t row, uint8_t col, const char *str) {
    printf("[%d, %d]: %s\n", row, col, str);
}

В одном разделе программы устанавливается указатель:

// Здесь мы узнаем, какое действие следует выполнить.
if (should_read()) {
    fun_ptr = (void(*)()) read_chars;
} else {  // should write
    fun_ptr = (void(*)()) write_chars;
}

и в другом разделе это называется:

// Здесь мы должны выполнить действие.
if (fun_ptr == (void(*)()) read_chars) {
    ((void(*)(uint8_t)) fun_ptr)(1);
} else if (fun_ptr == (void(*)()) write_chars) {
    ((void(*)(uint8_t, uint8_t, const char *)) fun_ptr)(
            1, 1, "messaage0");
}

Обратите внимание, что этот второй раздел должен знать, какую функцию он вызывает , чтобы передать правильные аргументы. Отсюда и тест "если...тогда". Обратите также внимание, что для того, чтобы иметь действительный C++, вы должны явно привести указатель на функцию перед ее вызовом. Это становится очень неуклюжим, и гораздо удобнее хранить эту информацию (какую функцию следует вызывать) в перечислении, а не в указателе функции:

enum {
    CALL_NONE, CALL_READ_CHARS, CALL_WRITE_CHARS
} what_to_call = CALL_NONE;

который будет использоваться следующим образом:

// Здесь мы узнаем, какое действие следует выполнить.
if (should_read()) {
    what_to_call = CALL_READ_CHARS;
} else {
    what_to_call = CALL_WRITE_CHARS;
}

// ...

// Здесь мы должны выполнить действие.
if (what_to_call == CALL_READ_CHARS)
    read_chars(1);
else if (what_to_call == CALL_WRITE_CHARS)
    write_chars(1, 1, "messaage1");

При этом часто бывает так, что, когда приходит время выполнить действие, часть кода, ответственная за это, не знает , какие аргументы должны быть переданы, и эта информация более доступна в то время, когда мы узнаем, какое действие следует выполнить. Это довольно распространенная ситуация, и стандартная идиома C в этом случае состоит в том, чтобы дать функции параметр void*, который она приведет к соответствующему типу для извлечения необходимых ей данных. Например:

void (*fun_ptr)(void *);
void *fun_ptr_data;

void read_chars(void * data) {
    uint8_t address = * (uint8_t *) data;
    printf("address of array is 0x%.2x\n", address);
}

struct write_chars_data {
    uint8_t row;
    uint8_t col;
    const char *str;
};

void write_chars(void *data) {
    write_chars_data *d = (write_chars_data *) data;
    printf("[%d, %d]: %s\n", d->row, d->col, d->str);
}

Обратите внимание, что, поскольку write_chars() должен извлекать несколько параметров из одного указателя, он использует указатель на структуру.

Теперь часть кода, которая определяет, что следует делать, несет ответственность за предоставление данных:

// Здесь мы узнаем, какое действие следует выполнить.
if (should_read()) {
    fun_ptr = read_chars;
    uint8_t *p = new uint8_t;
    *p = 1;
    fun_ptr_data = (void *) p;
} else {  // should write
    fun_ptr = write_chars;
    write_chars_data *p = new write_chars_data;
    p->row = 1;
    p->col = 1;
    p->str = "messaage2";
    fun_ptr_data = (void *) p;
}

Часть кода, которая должна выполнить действие сейчас, очень проста:

// Здесь мы должны выполнить действие.
if (fun_ptr)
    fun_ptr(fun_ptr_data);

Обратите внимание, что этот фрагмент кода не освобождает выделенную память. Вам придется выяснить, кто будет нести за это ответственность.

Этот шаблон довольно распространен в библиотеках, где клиент (пользователь библиотеки) хочет, чтобы было выполнено действие, но библиотека несет ответственность за выполнение этого действия в нужное время. Затем клиент предоставит библиотеке указатель на функцию, которая выполняет действие (называемое “обратным вызовом”), вместе с общим указателем на данные, необходимые для обратного вызова. Использование универсального указателя void * имеет смысл, поскольку библиотека не может знать, какие данные потребуются для обратного вызова.

В вашем случае, поскольку вы знаете, какие данные вам могут понадобиться, вы можете использовать указатель на объединение вместо общего указателя:

union fun_data {
    uint8_t address;  // для символов чтения
    struct {          // для символов записи
        uint8_t row;
        uint8_t col;
        const char *str;
    };
};

void (*fun_ptr)(fun_data *);
fun_data *fun_ptr_data;

Более идиоматичным стилем C++ было бы объединить функцию обратного вызова и ее данные в “функтор”, т. е. объект, который может быть вызван как функция, а также может хранить необходимые ему данные. Затем вы бы использовали наследование для создания определенных типов функторов при вызове универсального.