How do I store a function to a variable?

I think they are called functors? (it's been a while)

Basically, I want to store a pointer to a function in a variable, so I can specify what function I want to use from the command line.

all the functions return and take the same values.

unsigned int func_1 (unsigned int var1)
unsigned int func_2 (unsigned int var1)

function_pointer = either of the above?

so then I could call it by going: function_pointer(my_variable)?

EDIT: as per @larsmans's suggestion, I've gotten this: Config.h:

class Config
{
public:
    unsigned static int (*current_hash_function)(unsigned int);
};

Config.cpp:

#include "Config.h"
#include "hashes.h"
unsigned static int (*current_hash_function)(unsigned int) = kennys_hash_16;

hashes.h:

unsigned int kennys_hash(unsigned int out);
unsigned int kennys_hash_16(unsigned int out);

hashes.cpp:

just implements the functions in the header

main.cpp:

#include "Config.h"
#include "hashes.h"
// in test_network:
    unsigned int hashed = Config::current_hash_function(output_binary);

//in main():
        else if (strcmp(argv[i], "-kennys_hash_16") == 0)
        {
            Config::current_hash_function = kennys_hash_16;
        }
        else if (strcmp(argv[i], "-kennys_hash_8") == 0)
        {
            Config::current_hash_function = kennys_hash;
        }

the error I get:

g++ -o hPif src/main.o src/fann_utils.o src/hashes.o src/开发者_开发技巧Config.o -lfann -L/usr/local/lib 
Undefined symbols:
  "Config::current_hash_function", referenced from:
      test_network()     in main.o // the place in the code I've selected to show
      auto_test_network_with_random_data(unsigned int, unsigned int, unsigned int)in main.o
      generate_data(unsigned int, unsigned int, unsigned int)in main.o
      _main in main.o // the place in the code I've selected to show
      _main in main.o // the place in the code I've selected to show
      generate_train_file()     in fann_utils.o
ld: symbol(s) not found
collect2: ld returned 1 exit status
make: *** [hPif] Error 1

The simplest you can do is

unsigned int (*pFunc)(unsigned int) = func_1;

This is a bare function pointer, which cannot be used to point to anything other than a free function.

You can make it less painful if your compiler supports the C++0x auto keyword:

auto pFunc = func_1;

In any case, you can call the function with

unsigned int result = pFunc(100);

There are many other options that provide generality, for example:

• You can use boost::function with any C++ compiler
• With a compiler implementing features of C++0x you can use std::function

These can be used to point to any entity that can be invoked with the appropriate signature (it's actually objects that implement an operator() that are called functors).

Update (to address updated question)

Your immediate problem is that you attempt to use Config::current_hash_function (which you declare just fine) but fail to define it.

This defines a global static pointer to a function, unrelated to anything in class Config:

unsigned static int (*current_hash_function)(unsigned int) = kennys_hash_16;

This is what you need instead:

unsigned int (*Config::current_hash_function)(unsigned int) = kennys_hash_16;

From C++11 you can use std::function to store functions. To store function you use it as follsonig:

std::function<return type(parameter type(s))>

as an example here it is:

#include <functional>
#include <iostream>

int fact (int a) {
    return a > 1 ? fact (a - 1) * n : 1;
}

int pow (int b, int p) {
    return p > 1 ? pow (b, p - 1) * b : b;
}

int main (void) {
    std::function<int(int)> factorial = fact;
    std::function<int(int, int)> power = pow;

    // usage
    factorial (5);
    power (2, 5);
}

No, these are called function pointers.

unsigned int (*fp)(unsigned int) = func_1;

You could also use function either from the c++0x or from boost. That would be

boost::function<int(int)>

and then use bind to bind your function to this type.

Have a look here and here

Ok here would be a example. I hope that helps.

int MyFunc1(int i)
{
    std::cout << "MyFunc1: " << i << std::endl;
    return i;
}

int MyFunc2(int i)
{
    std::cout << "MyFunc2: " << i << std::endl;
    return i;
}

int main(int /*argc*/, char** /*argv*/)
{
    typedef boost::function<int(int)> Function_t;

    Function_t myFunc1 = boost::bind(&MyFunc1, _1);
    Function_t myFunc2 = boost::bind(&MyFunc2, _1);

    myFunc1(5);
    myFunc2(6);
}

You can store a function in a variable in c++ in this way

auto function_name = [&](params){
    statements 
};


auto add = [&](int a,int b){
    return a+b;
};
cout<<add(5,6);

typedef unsigned int (*PGNSI)(unsigned int);

PGNSI variable1 = func_1;
PGNSI variable2 = func_2;

unsigned int (* myFuncPointer)(unsigned int) = &func_1;

However, the syntax for function pointers is awful, so it's common to typedef them:

typedef unsigned int (* myFuncPointerType)(unsigned int);
myFuncPointerType fp = &func_1;

IF you have Boost installed, you can also check out Boost Function.