Нить таймера с переданной функцией * и параметром

Question

Я работаю над доработкой своего сервера для своего первого приложения для iPhone и хочу реализовать простую небольшую функцию.

Я хотел бы запустить функцию (возможно, также метод), если другая функция возвращает определенное значение после определенного периода ожидания. Довольно простая концепция .... верно?

Вот мой основной фундамент.

template <typename T,class TYP>
struct funcpar{
 T (*function)(TYP);
 TYP parameter;
 funcpar(T (*func)(TYP),TYP param);
 funcpar& operator=(const funcpar& fp);
}; 

Цель здесь - вызвать funcpar::function(funcpar::parameter), чтобы запустить сохраненную функцию и параметр, и не беспокоиться ни о чем другом ...

Когда я пытался использовать параметр void * вместо шаблона, я не мог скопировать память как объект (потому что я не знал, каким должен быть конечный объект или начало в этом отношении) и когда я попробовал несколько таймеров, параметр каждого отдельного объекта изменился бы на новый параметр, переданный новому таймеру ... С предыдущей структурой у меня есть

вопрос:

Можно ли сделать всеобъемлющий указатель на этот тип объекта внутри метода класса? Могу ли я шаблонизировать метод, а не весь класс? Будет ли он работать так же, как шаблон функции?

У меня есть управляющий класс, который содержит вектор этих "заданий" и довольно хорошо обо всем заботится. Я просто не знаю, как использовать шаблонизированную функцию со структурой или как использовать шаблоны для одного метода в классе.

_{Я также использую это в своем обычном простом пуле потоков, и он работает довольно хорошо и имеет те же проблемы ...}

У меня есть еще один вопрос:

Можно ли сохранить функцию с параметром до ее запуска? Что-то вроде toRun = dontrunmeyet(withThisParameter);? Моя структура вообще необходима?

Я неправильно все расскажу?

_{^{Если это слишком двусмысленно, я могу настроить весь код для контекста}}

Answer 1

Чтобы создать метод класса, который принимает параметр шаблона, да, он будет работать почти так же, как шаблон функции. Например:

class A
{
        public:
                template<typename T>
                void my_function(const T& value) { }
};

int main()
{
        A test;
        test.my_function(5);

        return 0;
}

Во-вторых, для вашей структуры вы можете на самом деле превратить это в functor-объект, который, перегружая operator(), позволяет вам вызывать структуру, как если бы она была функцией, вместо того, чтобы фактически вызывать определенные члены-указатели на функции внутри структура. Например, ваша структура может быть переписана так:

#include <iostream>

template <class ReturnType, class ParameterType>
class funcpar
{
    private:
        ReturnType (*function)(ParameterType);
        ParameterType parameter;

    public:
        funcpar(ReturnType (*func)(ParameterType),ParameterType param):
            function(func), parameter(param) {}

        funcpar& operator=(const funcpar& fp);

        //operator() overloaded to be a function that takes no arguments
        //and returns type ReturnType
        ReturnType operator() ()
        {
            return function(parameter);
        }
};


int sample_func(int value)
{
    return value + 1;
}


int main()
{
    funcpar<int, int> test_functor(sample_func, 5);

    //you can call any instance of funcpar just like a normal function
    std::cout << test_functor() << std::endl; 

    return 0;
}

Кстати, вам нужен объект функтора (или ваша структура и т. Д.), Чтобы связать динамический параметр с функцией перед вызовом функции в C / C ++ ... вы не можете "сохранить" параметр с реальной функцией. Привязка параметра к функции фактически называется замыканием, а в C / C ++ для создания замыкания требуется структура / класс или некоторый тип связанной структуры данных, которую можно использовать для связывания функции с конкретным параметром, хранящимся в памяти, который используется только для конкретного экземпляра этого вызова функции.