Re: Problem with function pointer

Philippe Amarenco wrote:

Sohail Ahmed Siddiqui <sohail@xxxxxxxxxxxxxxx> writes:

Hi,
i am working on a program which should connect to data server in one
thread, other threads will be used to update the UI and sorting data, in
some of the cases i have to use a function that should take int as
parameter and in some cases it has no parameter list. My class looks some
thing like this


class FunctionThread : public Threads
{
public:
typedef int (*Function)();
FunctionThread(Function function,
size_t stackSize=StackSize::DEFAULT,
Priority priority=Priority::INHERIT,
SchedulingPolicy schedpol=SchedulingPolicy::INHERIT,
const std::string& name="",
bool detached=true);
protected:
virtual int run();
private:
Function function_;

};

my function which enables me to make different threads i am using

FunctionThread::FunctionThread(Function function,
size_t stackSize,
Priority priority,
SchedulingPolicy schedpol,
const std::string& name, bool detached)
: Threads(stackSize, priority, schedpol, name, detached,1)
{}

int FunctionThread::run()
{
return (*function_)();
}

This works very well with functions that have no parameters, but if i
change typedef int (*Function)(); to typedef int (*Function)(int); some
how it doesn't seem to work at all, can some one please tell me how can i
change this so that it can take int as normal parameters?


then where that extra 'int' parameter comes from? do you add it as a
parameter to the 'FunctionThread::run()' method?

Basically i want to use it like:
i wait till i get a transaction number from user and then i create a thread
and come back to UI while the thread works and gets the information

Transaction* trans = new Transaction(transNo);//this is the uint32_t

Transaction class has a worker thread from FunctionThread class

class Transaction
{
public:
Transaction(uint32_t transNo);
virtual ~Transaction();
static int transact()
private:
uint32_t transaction_;
FunctionThread worker_;
};

and
Transaction::Transaction(uint32_t transNo)
:worker_(StackSize::0x10000,
Priority::NORMAL,
SchedulingPolicy::FIFO,
"Transaction",false),
transaction_(transNo)
{
worker_.start();
}

Transaction::transact()
{
// connect to server and get the transaction from server
}

If I had to do it, i would replace Function by a function object:

class Function
{
public:
virtual void execute() = 0;
void operator() { execute(); }
};

If you need a function that takes an 'int' as parameter and returns an
'int', you simply do that:

class FunctionInt : public Function
{
int _param;
int _ret;
public:
FunctionInt(int i) : _param(i) {}
void execute() {
/* _ret = _param; */
}
int get_result() const { return _ret; }
};

so your FunctionThread object can handle any type of function without
knowning its requirements.


.

Relevant Pages