Передача большего количества параметров в указателях функций C

Ах, если бы только C поддерживал closures...

Антонио прав; если вам нужно передать дополнительные параметры, вам нужно будет переопределить указатель функции, чтобы принять дополнительные аргументы. Если вы не знаете точно, какие параметры вам понадобятся, то у вас есть по крайней мере три варианта:

1. Пусть последним аргументом в вашем прототипе будет void*., это дает вам гибкость передачи всего остального, что вам нужно, но это определенно не типобезопасно.
2. Используйте переменные параметры (...). Учитывая мой недостаточный опыт работы с вариадическими параметрами в C, я не уверен, что вы можете использовать это с указателем функции, но это дает еще большую гибкость, чем первое решение, хотя и с отсутствием безопасности типов.
3. Обновите до C++ и используйте объекты функций .

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

void foreachMove( void (*action)(chess_move*, int), chess_game* game )

Если вы хотите использовать некоторые C++, вы можете использовать " объект функции":

struct MoveHandler {
    chess_game *game;
    int depth;

    MoveHandler(chess_game *g, int d): game(g), depth(d) {}

    void operator () (chess_move*) {
         // now you can use the game and the depth
    }
};

и превратите ваш foreachMove в шаблон:

template <typename T>
void foreachMove(T action, chess_game* game);

и вы можете назвать это так:

chess_move getNextMove(chess_game* game, int depth){
    //for each valid move, determine how good the move is
    foreachMove(MoveHandler(game, depth), game);
}

но это не помешает вам использовать MoveHandler в других целях .

Если я правильно читаю это, то я бы предложил сделать так, чтобы ваша функция принимала указатель на структуру в качестве аргумента. Затем ваша структура может иметь "game" и "depth", когда они ей нужны, и просто оставить их равными 0 или Null, когда они вам не нужны.

Что происходит в этой функции? У вас есть условный знак, который говорит:,

if (depth > -1) //some default
  {
  //do something
  }

Всегда ли функция REQUIRE "game" и "depth"? Затем они всегда должны быть аргументами, и это может войти в ваши прототипы.

Вы хотите сказать, что функция только иногда требует "game" и "depth"? Ну, может быть, сделать две функции и использовать каждую из них, когда вам это нужно.

Но, имея структуру в качестве аргумента, вероятно, самая простая вещь.

Я бы предложил использовать массив void*, с последней записью всегда void. скажем вам нужно 3 параметра вы могли бы сделать это:

void MoveHandler (void** DataArray)
{
    // data1 is always chess_move
    chess_move data1 = DataArray[0]? (*(chess_move*)DataArray[0]) : NULL; 
    // data2 is always float
    float data1 = DataArray[1]? (*(float*)DataArray[1]) : NULL; 
    // data3 is always char
    char data1 = DataArray[2]? (*(char*)DataArray[2]) : NULL; 
    //etc
}

void foreachMove( void (*action)(void**), chess_game* game);

и затем

chess_move getNextMove(chess_game* game, int depth){
    //for each valid move, determine how good the move is
    void* data[4];
    data[0] = &chess_move;
    float f1;
    char c1;
    data[1] = &f1;
    data[2] = &c1;
    data[3] = NULL;
    foreachMove(moveHandler, game);
}

Если все параметры имеют одинаковый тип, то вы можете избежать массива void* и просто отправить массив NULL-terminated любого типа, который вам нужен.

+1 к Антонио. Вам нужно изменить объявление указателя функции, чтобы принять дополнительные параметры.

Кроме того, Пожалуйста, не начинайте передавать пустые указатели или (особенно) массивы пустых указателей. Это просто напрашивается на неприятности. Если вы начнете передавать пустые указатели, вам также придется передать какое-то сообщение, чтобы указать, что такое тип указателя (или типы). Этот прием редко бывает уместен.

Если ваши параметры всегда одинаковы, просто добавьте их в аргументы указателя функции (или, возможно, упакуйте их в структуру и используйте ее в качестве аргумента, если параметров много). Если ваши параметры изменяются, то рассмотрите возможность использования нескольких указателей функций для нескольких сценариев вызовов вместо передачи указателей void.

Если ваши параметры изменятся, я бы изменил объявление указателя функции, чтобы использовать "..."техника установки переменного числа аргументов. Это может сэкономить вам читабельность, а также необходимость вносить изменения для каждого параметра, который вы хотите передать функции. Это определенно намного безопаснее, чем передавать пустоту вокруг.

http://publications.gbdirect.co.uk/c_book/chapter9/stdarg.html

Просто FYI, о примере кода в ссылке: в некоторых местах у них есть “n args”, а в других-“n_args” с подчеркиванием. Они все должны иметь подчеркивание. Я подумал, что синтаксис выглядит немного забавно, пока не понял, что они опустили подчеркивание в некоторых местах.

Используйте typedef для указателя функции. Смотрите мой ответ на этот вопрос

Другой вариант-изменить структуру chess_move вместо прототипа функции. Структура, по-видимому, уже определена только в одном месте. Добавьте элементы в структуру и заполните структуру соответствующими данными перед любым вызовом, который ее использует.