vector of function pointers

I'm trying to achieve the following:
(1) main() should not be modified by my user
(2) user provides a file (or files) containing functions all of the same type and same number and type of arguments, but the details of what the functions do are left to the user.
(3) main somehow gets a vector of pointers to those functions and the determination of which functions are called occurs at runtime.

I came up with the following dumb example of how I can accomplish this (the user would provide both funcs.h and func.cpp), but I'm wondering if there's a better way. I'm not thrilled with the idea of making the user include the array (funcArr) of function pointers, but I couldn't think of any other way to load main's funcs vector.

Code:

---

// fn_pointer.cpp

#include <iostream>
#include <vector>
#include "funcs.h"
using namespace std;


int main () {
  vector<int (*)(int,int)> funcs(&(*funcArr), &(*funcArr)+NUM_FUNCS);
  int x,y,op,sum;
  cout << "1. add\n2. multiply\n\tChoose 1 or 2\n";
  cin >> op;
  cout << "enter 2 operands:\n";
  cin >> x >> y;
  sum = funcs[op-1](x,y);
  cout << "the result is " << sum << "\n";
}

---

Code:

---

// funcs.h

#ifndef funcs_h_
#define funcs_h_

const int NUM_FUNCS = 2;
int add(int,int);
int mult(int,int);

int (*funcArr[])(int, int) = {add, mult};

#endif

---

Code:

---

// funcs.cpp

int add(int x, int y) {return x + y;}
int mult(int x, int y) {return x * y;}

---

What is the purpose of doing this?

One way of doing this is to make use of some kind of "registry" (presumably a singleton). Each user defined function would have to register themselves, then the main function would merely consult the registry to determine what functions to call.

Perhaps a user-supplied init() function, which takes your funcs vector as a ref parameter would be better.

But then how do you know that "1" is "add" ?

If you used a map, like
map< string, int (*)(int,int) > funcs;

Then
funcs["add"] = add;
could be done by the user.

Then in your main(), you could print out the key names as part of your menu.

Sorry, the menu is just something I threw in there so I could see that the pointers were doing what I wanted. I've never done a vector of function pointers before. Main doesn't have to know what the functions do. The arguments will all be const so the only requirement is that they return "allowed" values. I'll have code in main to ensure that.

It's a driver program for a research project - game theory actually. Main runs the games, keeps track of scores, prints results, etc. funcs.cc provides the rules determining the players' moves. I'm trying to make it as convenient as possible to modify the set of available rules.

Maybe I'm missing something, but I don't see why a user-supplied init() function would be better. The user would still need some sort of list of the functions or pointers to them, for the init() to iterate through in order to load the vector, right? Simply providing an array seems to be easier.

Laserlight, I'm curious about your suggestion, but I really have no idea what that would look like (or what a singleton is). Can you point me to something to read that explains it?

Quote:

---

Originally Posted by R.Stiltskin

Laserlight, I'm curious about your suggestion, but I really have no idea what that would look like (or what a singleton is). Can you point me to something to read that explains it?

---

You should search the Web for singleton pattern. The pattern itself is less important than the idea that functions register themselves.

I suggested the registry idea because it is used in some unit test frameworks. Unit test frameworks face a similiar problem as you: ideally, the driver code is written once and users add tests in one or more source files. When new tests are added there should be no need to modify the driver code. If there was, then failure to update that file would mean that the new test is not run, which is a Bad Thing. On the other hand, failure to update the registry would mean the same thing, so the frameworks may end up requiring the use of macros or template magic to ensure that tests are always registered.

That may be more complicated than I need for this purpose, but it sounds interesting anyway so I will look into it. Thanks.

A singleton is a very basic concept really.
You can use lazy instantiation, or controlled. Lazy is fine if it does not matter who/what creates the singleton first, but is not ok if the creation time matters(rare case IMO).

This is a basic class using lazy instantiation.(not tested so may have syntax error)

Code:

---

class MySingleton
{
private:
  MySingleton() {};
  ~MySingleton() {};

  static MySingleton* m_Singleton;

public:
  static MySingleton* Get()
  {
    if ( !m_Singleton )
        m_Singleton = new MySingleton();
    return m_Singleton;
  }

  static void Release()
  {
      if ( m_Singleton )
      {
        delete m_Singleton;
        m_Singleton = 0;
      }
    }
};

//To use it
MySingleton* Test = MySingleton::Get();

//Don't forget to release it when your done
MySingleton::Release();

---

The other way is pretty simple to figure out.

Quote:

---

The pattern itself is less important than the idea that functions register themselves.

---

Can you elaborate on this issue?

I'm... extremely curious as to how you would handle this.

Soma

Quote:

---

Originally Posted by phantomotap

Can you elaborate on this issue?

---

Take a look at TUT and UnitTest++ since these are the unit test frameworks I had in mind when I suggested the registry idea. The last I rumaged through TUT's code some time back it had a registry as a singleton and used template magic to have test functions automatically register themselves (unfortunately, it also appeared to abuse exception handling to control the flow of control). UnitTest++ uses macros instead, but despite being a regular UnitTest++ user I must confess that I have not taken a deep enough look into how it works to explain how it does automagic test detection.

Quote:

---

Take a look at TUT [...] does automagic test detection.

---

I see.

Well, from what I can guess from the provided examples:

'TUT' uses a fully specialized template as a discontinuous namespace for defining template functions which all share the same name and performs simple recursion to register the valid ones. (That's actually pretty clever, but it isn't a full testing framework.)

'UnitTest++' looks like a truly evil affair by using macros as a means of mugging the names of target functions for creating classes and super classes which register the given test or suite in the constructor of the generated class. (Which is very ugly besides, but it does seem to provide more testing primitives than I usually see.)

The thing is, neither of these actually present a solution where the function "registers" itself. I was expecting something more like:

Code:

---

bool testing
(
  suite & f
)
{
  registry<my_test_suite>::register_function<&testing>();
  return(0 == 0); // Whatever!
}

---

Which in my opinion would provide semantics and context.

Unfortunately, my library is the only code I've ever seen doing it.

I'm always on the lookout for better methods you see.

Thanks anyway.

Soma

I'm still playing with this, primarily out of curiousity. I think that my main function's vector of function pointers serves as a "registry" -- I don't see why anything more elaborate is needed. The question is just how it gets loaded.

Implementing Salem's suggestion is straightforward enough:

Code:

---

// fn_pointer2.cpp

#include <iostream>
#include <vector>
#include "funcs2.h"
#include <cassert>
using namespace std;


int main () {
  vector<int (*)(int,int)> funcs;
  functions::regis(funcs);
  assert(!funcs.empty());
  int x,y,op,sum;
  cout << "1. add\n2. multiply\n\tChoose 1 or 2\n";
  cin >> op;
  cout << "enter 2 operands:\n";
  cin >> x >> y;
  sum = funcs[op-1](x,y);
  cout << "the result is " << sum << "\n";
}

---

Code:

---

// funcs2.h

#ifndef funcs2_h_
#define funcs2_h_

#include <vector>
struct functions {

static int add(int,int);
static int mult(int,int);

static void regis( std::vector<int (*)(int,int)>& );
};

#endif

---

Code:

---

// funcs2.cpp
#include "funcs2.h"

// user-provided registration function:
// user can implement this either by adding a line for each function
// or by iterating through an array containing a pointer to each function
void functions::regis(std::vector<int (*)(int,int)> &registry) {
  registry.push_back(&add);
  registry.push_back(&mult);
}

int functions::add(int x, int y) {return x + y;}

int functions::mult(int x, int y) {return x * y;}

---

Then I thought I would see how this would be done in a class or struct. So I wrapped the functions in a struct (called "functions") & gave it a constructor that takes a vector of function pointers as an argument. Since now these are member functions, I had to change the type of the vector to <int (functions::*)(int,int)>. But now the compiler is complaining about the way the main function uses the pointers to call the functions & I can't figure out what it wants me to do.

Here's the error:

Code:

---

g++ fn_pointer3.cpp funcs3.cpp
fn_pointer3.cpp: In function `int main()':
fn_pointer3.cpp:20: error: must use .* or ->* to call pointer-to-member
  function in `(&funcs)->std::vector<_Tp, _Alloc>::operator[] [with _Tp = int
  (functions::*)(int, int), _Alloc = std::allocator<int (functions::*)(int,
  int)>]((op - 1)) (...)'

---

and here's the code:

Code:

---

// fn_pointer3.cpp

#include <iostream>
#include <vector>
#include "funcs3.h"
#include <cassert>
using namespace std;


int main () {
//  vector<int (*)(int,int)> funcs;
  vector<int (functions::*)(int,int)> funcs;
  functions f(funcs);
  assert(!funcs.empty());
  int x,y,op,sum;
  cout << "1. add\n2. multiply\n\tChoose 1 or 2\n";
  cin >> op;
  cout << "enter 2 operands:\n";
  cin >> x >> y;
  sum = funcs[op-1](x,y);
  cout << "the result is " << sum << "\n";
}

---

Code:

---

// funcs3.h

#ifndef funcs3_h_
#define funcs3_h_

#include <vector>
struct functions {
  functions( std::vector<int (functions::*)(int,int)> );

  int add(int,int);
  int mult(int,int);

};

#endif

---

Code:

---

// funcs3.cpp
#include "funcs3.h"

int functions::add(int x, int y) {return x + y;}

int functions::mult(int x, int y) {return x * y;}

functions::functions(std::vector<int (functions::*)(int,int)> registry) {
  registry.push_back(&functions::add);
  registry.push_back(&functions::mult);
}

---

http://cboard.cprogramming.com/showthread.php?t=110041

NB:

http://cboard.cprogramming.com/showp...23&postcount=8

it also sounds like you might want to look into explicitly importing DLLs if you want to do this in a file-based context at runtime.

Quote:

---

Originally Posted by m37h0d

it also sounds like you might want to look into explicitly importing DLLs if you want to do this in a file-based context at runtime.

---

Yes, I need to learn a great deal about DLLs (including creating them) but that's another whole subject, for another day ...

Quote:

---

Originally Posted by m37h0d

NB:

http://cboard.cprogramming.com/showp...23&postcount=8

---

Sorry, but this only adds another layer to my confusion. If I read this correctly you have created a new type tfptr which includes among its members an instance of a class c, a pointer to a member function of c, and a member function exec() (of tfptr) which calls c's member function. The thing that you are putting into the container is a pointer to the tfptr object, so it makes sense that when you retrieve it from the container you use -> to call its exec() function.

That's clearly different from my vector which contains pointers to member functions of my "functions" object. Are you saying that what I'm trying to do is illegal? Or am I just not seeing an answer that is staring me in the face?

Quote:

---

That's clearly different [...] staring me in the face?

---

O_o

I think the suggestion was offered because it can simplify the implementation of additional features. That doesn't change the registration requirement or imply that your now doing something illegal. You see, by storing a generated function object you can easily support simple functions but you can also, for example, bind an object to a member function so that you might perform the same mechanical test on different prefabricated data without complicating the implementation of the tests themselves.

Soma

i offered it up because i thought it was relevant to your attempts to store the pointer-to-member functions in a vector.

if you succeed in navigating the syntax of calling a pointer-to-member function from an STL container, you will get an error saying: "illegal use of member pointer" (IIRC) . though perhaps this is specific to set, as in the cited thread, and does not apply to vectors.

using a function object both skirts this limitation and simplifies the syntax; not to mention simplifying your life by being able to process the i/o of the function on each call with no additional effort. using a derived template allows you to store functions that varying types and numbers of arguments in the same container and invoke them through the base class' virtual invocation method (exec)

Thanks, I appreciate that m37h0d's approach is much more versatile. But right now I'm trying to understand this particular error. Maybe it is even clearer if I modify the main function code, effectively taking the STL container out of the picture

Code:

---

// fn_pointer3.cpp

#include <iostream>
#include <vector>
#include "funcs3.h"
#include <cassert>
using namespace std;


int main () {
//  vector<int (*)(int,int)> funcs;
  vector<int (functions::*)(int,int)> funcs;
  functions f(funcs);
  assert(!funcs.empty());
  int x,y,op,sum;
  cout << "1. add\n2. multiply\n\tChoose 1 or 2\n";
  cin >> op;
  cout << "enter 2 operands:\n";
  cin >> x >> y;
  int (functions::*fptr)(int,int);
  fptr = *funcs.begin();
  sum = fptr(x,y);
  cout << "the result is " << sum << "\n";
}

---

Now the error is simply

Code:

---

In function `int main()':
fn_pointer3.cpp:22: error: must use .* or ->* to call pointer-to-member
  function in `fptr (...)'

---

So, is it illegal to use a member function pointer from outside of the class, even if the member function is public?

You can't use a member function without an object.
You can't use a pointer to a member function without an object.

You need to read that thread he linked a few more times.

Soma

Quote:

---

Originally Posted by phantomotap

You need to read that thread he linked a few more times.

Soma

---

I've read it. The problem is different. My vector is not the source of the problem The problem is how to use the member function pointers.
I accept your statement that "You can't use a member function without an object. You can't use a pointer to a member function without an object."
But if I modify the next-to-last line of my code just above (post # ) to

Code:

---

sum = f.fptr(x,y)

---

similar to the way you might use an ordinary (non-member) function pointer, I get an error

Code:

---

error: 'fptr' undeclared (first use this function)

---

which I suppose makes sense because f does not have a member called 'fptr'. But if I change it to

Code:

---

sum = f.(*fptr)(x,y)

---

I get an error

Code:

---

error: syntax error before '*' token
error: invalid use of 'unary *' on pointer to member

---

There is no error associated with the line "fptr = *funcs.begin();

and this is interesting... If I modify the code as follows, it compiles and runs, but fails at the FIRST assert - although the types are consistent, the functions constructor doesn't put anything into the vector.

Code:

---

// fn_pointer3.cpp MODIFIED

#include <iostream>
#include <vector>
#include "funcs3.h"
#include <cassert>
using namespace std;


int main () {
//  vector<int (*)(int,int)> funcs;
  vector<int (functions::*)(int,int)> funcs;
  functions f(funcs);
  assert(!funcs.empty());
  int x,y,op,sum;
  cout << "1. add\n2. multiply\n\tChoose 1 or 2\n";
  cin >> op;
  cout << "enter 2 operands:\n";
  cin >> x >> y;
  int (functions::*fptr)(int,int);
  fptr = *funcs.begin();
  assert (fptr == &functions::add);
//  sum = f.(*fptr)(x,y);
//  cout << "the result is " << sum << "\n";
}

---

(using the same funcs3.h and funcs3.cpp as in post #11)

Anyway, this seems to be going nowhere. Function objects are not the same thing as pointers to member functions. Don't the unit test libraries that laserlight mentioned use pointers to member functions? Or not? I wouldn't expect that all classes that are tested by those tools must have each function in its own class.

In fact it has nothing to do with STL containers at all. I just added a functions class constructor that takes a single int (functions::*)(int,int) and supposedly assigns &functions::add to it. Main declares an
int (functions::*fptr)(int,int)=NULL;
and calls the new constructor passing it fptr. It compiles and runs, but halts on assert(fptr).

no, your problem is not different. soma is telling you the information you need, he's just not elaborating very much.

to call an pointer-to-member function, you have to have two pieces of information: an instance of the class that will invoke the method, and the method you want called.

you aren't storing an instance of the object.

if you insist on banging on in this way, perhaps you could use a vector of pairs (or a map), and store the class instance in pair::first and the function in pair::second, then do something like

containerType::iterator it = container.begin();
(it->first.*it->second)(arg)

this might not work, but it should have everything required to call the pointer-to-member function. it was meant to demonstrate that you are missing information required to call the member function.

that does, in fact, work.

Code:

---

//---------------------------------------------------------------------------
#include <map>
#include <vcl.h>
#pragma hdrstop

//---------------------------------------------------------------------------

#pragma argsused
class c
{

        public:

        int func(int i0,int i1)
        {
                return i0+i1;
        }
};
int main(int argc, char* argv[])
{
        typedef int (c::*iiifuncptr)(int,int);
        typedef std::map<c*,iiifuncptr>cFuncMap;
        cFuncMap fm;
        c c1;
        fm[&c1]=&c::func;
        cFuncMap::iterator it = fm.begin();
        int i = (*it->first.*it->second)(1,2);
        return 0;
}
//---------------------------------------------------------------------------

---

In your example, the code that stores the member function pointer is outside the class. I'm trying to do something from within the class - in the constructor.
This code compiles & runs but leaves the function pointer fptr NULL. Why?

Code:

---

#include <iostream>
#include <cassert>

class c {
  public:
  c(int (c::*fptr)(int,int)) {
      fptr = &c::add;
      std::cout << "finished c constructor\n";
  }
  int add(int x,int y) {return x+y;}
  int mult(int x,int y) {return x*y;}
};


int main () {
  int (c::*fptr)(int,int) = NULL;
  c f(fptr);
  std::cout << fptr << "\n";
  assert(fptr);
}

---

You don't expect to be able to change the value of a non-reference variable inside a function, do you?

That would seem to be a bad thing. On the other hand, the compiler doesn't seem to mind.

I tried to make the pointer const, but couldn't figure out any syntax to accomplish that.

Code:

---

//---------------------------------------------------------------------------
#include <iostream>
#include <cassert>

#include <vcl.h>
#pragma hdrstop

//---------------------------------------------------------------------------

#pragma argsused

class c {
  public:
  c(int (c::**fptr)(int,int)) {
      *fptr = &c::add;
      std::cout << "finished c constructor\n";
  }
  int add(int x,int y) {return x+y;}
  int mult(int x,int y) {return x*y;}
};



int main(int argc, char* argv[])
{
  int (c::*fptr)(int,int) = NULL;
  c f(&fptr);
  std::cout << fptr << "\n";
  assert(fptr);
}
//---------------------------------------------------------------------------

---

This is probably a waste of time. Your code puts something in fptr, but I still can't work out how to use it.
This, for example, won't compile

Code:

---

#include <iostream>
#include <cassert>

//#include <vcl.h>
//#pragma hdrstop

//---------------------------------------------------------------------------

//#pragma argsused

class c {
  public:
  c(int (c::**fptr)(int,int)) {
      *fptr = &c::add;
      std::cout << "finished c constructor\n";
  }
  int add(int x,int y) {return x+y;}
  int mult(int x,int y) {return x*y;}
};



int main(int argc, char* argv[])
{
  int (c::*fptr)(int,int) = NULL;
  c f(&fptr);
  std::cout << fptr << "\n";
  assert(fptr);
  int result = f.(*fptr)(1,2);

}

---

nor will any other combination of f . -> *() that I have tried, following the compiler's suggestions.

The error message says that you need to use .* to call a member pointer. I would believe it, if I were you.

Code:

---

int result = (f.*fptr)(1,2);

---

Apparently I didn't try ALL permutations.

Thanks. I will need some time to think about what I have learned from this discussion. :p

What about your question a few posts back? Does this pointer now allow messing around with the member function itself - violating the encapsulation?