Function pointers

[jhapk]

Hi,

this piece of code compiles fine

 double Multiply(void) {return 1.0;} ;
 double (*GetFPointer(void))(void) {
    return &Multiply;
 }

int main(){
  return 0;
}

but if I try to include these functions in a class like this:

class T{
double Multiply(void) {return 1.0;} ;
double (*GetFPointer(void))(void) {
  return &Multiply;
  }
};

int main(){
  return 0;
}

I get the following compilation error:

check.cc: In member function ‘double (* T::GetFPointer())()’:
check.cc:4: error: ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function.  Say ‘&T::Multiply’
check.cc:4: error: cannot convert ‘double (T::*)()’ to ‘double (*)()’ in return

What am I doing wrong?

[Zhuge]

Function pointers to class methods have an implied this parameter, making them different from a normal function. You need to change you function pointer to reflect that.

[Athar]

The error message basically says all.
You cannot call a non-static member function without an object.
In this case, it would make sense to make the functions static or rather to put them into a namespace instead of a class.

[Bazzy]

pointers to member functions have a quite awful syntax:

class T
{
    public:
        double Multiply(void) {return 1.0;}
        typedef double (T::*fptr)(void); // typedef for better readability 
        fptr GetFPointer(void)
        {
            return &T::Multiply;
        }
};

int main()
{
    T t;
    T::fptr p;
    p = t.GetFPointer(); // get function pointer
    (t.*p)(); // call function pointer
  return 0;
}

[jhapk]

Thanks Bazzy.. That solved the problem.

[jhapk]

I have a follow up question. The following code is broken. But is it possible to set up something like this?

#include <iostream>
using namespace std;
class T{
public:
  double Multiply(double var) {return var*2.0;} ;
  double Divide(double var) {return var/2.0;} ; 
  typedef double (T::*fptr)(double);

  fptr GetFpointer(bool arg){
    if (arg) return &T::Multiply;
    else return &T::Divide;
  }
   // code which sets a function called Operation 
   set_function(bool mult){
  if(mult) {/*Operation is set to  multiply*/};
  else {/*Operation is set to divide*/};
 }


};


int main(){

//something like this will be nice
T t;
t.set_function(1);
cout<< t.Operation(40)<<endl;
  return 0;
}

[m4ster r0shi]

jhapk wrote:

But is it possible to set up something like this?

Sure!

#include <iostream>
using namespace std;
class T
{
public:

    enum OPCODE {ADD=0,SUB=1,MUL=2,DIV=3};

    void SetOperation(OPCODE op_code)
    {
        cur_op=op_table[op_code];
    }

    double DoOperation(double var)
    {
        return (this->*cur_op)(var);
    }

private:

    double Add(double var) {return var+5.0;}
    double Sub(double var) {return var-5.0;}
    double Mul(double var) {return var*2.0;}
    double Div(double var) {return var/2.0;}

    typedef double (T::*fptr)(double);

    static const fptr op_table[4];
    fptr cur_op;
};

const T::fptr T::op_table[]=
{
    &T::Add,&T::Sub,&T::Mul,&T::Div
};

int main()
{
    T t;

    t.SetOperation(T::ADD);
    cout << t.DoOperation(50) << endl;

    t.SetOperation(T::SUB);
    cout << t.DoOperation(50) << endl;

    t.SetOperation(T::MUL);
    cout << t.DoOperation(50) << endl;

    t.SetOperation(T::DIV);
    cout << t.DoOperation(50) << endl;

    cout << "\nhit enter to quit";
    cin.get();
    return 0;
}

[jhapk]

Hi,

thank you so much for that reply. It works really well. Can you please explain though, whats happening in the following line:

const T::fptr T::op_table[]=
{
    &T::Add,&T::Sub,&T::Mul,&T::Div
};

I am not able to understand it.

[Zhuge]

It's creating an array of function pointers, with the first element being a pointer to Add(), and so on.

[jhapk]

Hi,

I am trying to implement the above code by m4ster r0shi in a group code for a particular class "Class_Name". Inside my class declaration I have these statements

Class Class_Name{
public:
 //other stuff

   typedef void (Class_Name::*fptr)(const int B);

   static const fptr set_wall[2];
   fptr apply_wall;

   void apply_wall(const int B){
     (this->*apply_wall)(B);
   }

 void set_function(const int  A){                                                                                           
     bool C = !A;                                                                        
     apply_wall=set_wall[C];                                                                    
   }  

  void wall (const int B);
  void no_wall(const int B);
};

And outside the class declaration, I have these lines

void Class_Name::wall(const int B){
/* description of wall function */
}

void Class_Name::no_wall(const int B){
/* description of no_wall function */
}
const Clas_Name::fptr Class_Name::set_wall[]=
  {
    &Class_Name::no_wall,
    &Class_Name::wall
  };

I use a makefile to compile this group code. And all the individual files compile fine, but while linking the files I get the following error message at the very end of the compiling process

'Filename.o:(.rodata+0x72c): multiple definition of `Class_Name::set_wall'
Filename.o:(.rodata+0x10): first defined here

Any clues?

[m4ster r0shi]

Ah, you probably have this:

const Clas_Name::fptr Class_Name::set_wall[]=
{
    &Class_Name::no_wall,
    &Class_Name::wall
};

inside a header file that you include more than one times in your code. Try removing it from here (from the header) and putting it in a separate cpp file (in which you will also include your header of course).

[jhapk]

you were right m4ster r0shi. Thanks a lot.

[jhapk]

Is it possible to make the SetOperation function in the original code by "m4ster r0shi" static? I am getting compile time errors with that. Anything logically wrong with that?

[jhapk]

Basically, I just want to "SetOperation()" once in the very beginning of the run depending on some input parameters and not touch it again. Is it possible to do it without actually initializing an object of the class?

[m4ster r0shi]

You can make SetOperation static but then you also have to make cur_op static, as static functions can't operate on non-static members.

EDIT:

jhapk wrote:

Is it possible to do it without actually initializing an object of the class?

Don't use a class at all. And if you really want to wrap your functions use a namespace instead.

http://www.cplusplus.com/doc/tutorial/namespaces/

EDIT 2: Oh, I guess you want to protect the private members... Then stick with the class but make all members static.

[m4ster r0shi]

Ok, this is what it should look like:

#include <iostream>
using namespace std;

class T
{
public:

    enum OPCODE {ADD=0,SUB=1,MUL=2,DIV=3};

    static void SetOperation(OPCODE op_code)
    {
        cur_op=op_table[op_code];
    }

    static double DoOperation(double var)
    {
        return (*cur_op)(var);
    }

private:

    static double Add(double var) {return var+5.0;}
    static double Sub(double var) {return var-5.0;}
    static double Mul(double var) {return var*2.0;}
    static double Div(double var) {return var/2.0;}

    typedef double (*fptr)(double);

    static const fptr op_table[4];
    static fptr cur_op;
};

const T::fptr T::op_table[]=
{
    &T::Add,&T::Sub,&T::Mul,&T::Div
};

T::fptr T::cur_op;

int main()
{

    T::SetOperation(T::ADD);
    cout << T::DoOperation(50) << endl;

    T::SetOperation(T::SUB);
    cout << T::DoOperation(50) << endl;

    T::SetOperation(T::MUL);
    cout << T::DoOperation(50) << endl;

    T::SetOperation(T::DIV);
    cout << T::DoOperation(50) << endl;

    cout << "\nhit enter to quit";
    cin.get();
    return 0;
}

[jhapk]

thanks m4ster r0shi. this is exactly I wanted.