Pointer to array of pointers to functions

Question

The idea is to call different functions based on their index in table. But line 27 generates the runtime error (( I tried to fix but didn't succeed ((( Here's the simplified code:

#include <iostream>

void f1 (void) {
  std::cout << "f1" << "\n";
}

void f2 (void) {
  std::cout << "f2" << "\n";
}

typedef void (*fPtr[3])(void); // simple "[]" instead of "[3]" gets the compile error

class modeChanger {
  public:
    modeChanger (fPtr funcArray);
    void op ();
  private:
    fPtr *_funcArray;
};

modeChanger::modeChanger (fPtr funcArray) {
  _funcArray = (fPtr *) funcArray;
}

void modeChanger::op () {
  (*_funcArray[0])();
  (*_funcArray[1])(); // Line 27: this line generates a runtime error! Just comment it to get all work
}

void (*modeFuncArray[])(void) = {f1, f2, f2};

modeChanger *mode = new modeChanger (modeFuncArray);

int main() {
    (*modeFuncArray[1])(); // Works fine

    mode->op(); // generates a runtime error
    return 0;
}

This works good:

(*_funcArray[0])();

as well as this:

(*modeFuncArray[1])();

but this generates a runtime error...

(*_funcArray[1])();

Seems that incrementing of _funcArray is incorrect for some reason.

Firsst thing to do is to not try to shut up compiler warnings by using casts... those warnings are telling you something. (referring to _funcArray = (fPtr *) funcArray;) — M.M
– M.M, Commented Apr 20, 2018 at 13:26
May I suggest you stop using raw function pointers in C++? Use std::function instead. That will make much of your code simpler. Then if you use a standard container like std::vector or std::array then you simplify even further. Simple code have less chance of errors or problems. — Some programmer dude
– Some programmer dude, Commented Apr 20, 2018 at 13:27
Once you've done as M.M says, a read of ericlippert.com/2014/03/05/how-to-debug-small-programs will be invaluable. — UKMonkey
– UKMonkey, Commented Apr 20, 2018 at 13:28
Regarding the comment by @M.M, almost always when you need to use a C-style cast in C++, you're most likely doing something wrong. — Some programmer dude
– Some programmer dude, Commented Apr 20, 2018 at 13:31

3CEZVQ · Accepted Answer · 2018-04-20 13:34:22Z

3

fPtr *_funcArray; this is the pointer to array, not an array of pointers. You suppressed warnings with help of type casts. See bellow the fixed code.

#include <iostream>

void f1 (void) {
  std::cout << "f1" << "\n";
}

void f2 (void) {
  std::cout << "f2" << "\n";
}

typedef void (*fPtr)(void);

class modeChanger {
  public:
    modeChanger (fPtr *funcArray);
    void op ();
  private:
    fPtr *_funcArray;
};

modeChanger::modeChanger (fPtr *funcArray) {
  _funcArray = funcArray;
}

void modeChanger::op () {
  (*_funcArray[0])();
  (*_funcArray[1])(); // Line 27: this line generates a runtime error! Just comment it to get all work
}

void (*modeFuncArray[])(void) = {f1, f2, f2};

modeChanger *mode = new modeChanger (modeFuncArray);

int main() {
    (*modeFuncArray[1])(); // Works fine

    mode->op(); // generates a runtime error
    return 0;
}

edited Apr 20, 2018 at 13:34

answered Apr 20, 2018 at 13:28

3CEZVQ

42.9k11 gold badges91 silver badges100 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Some programmer dude Over a year ago

Why not change the declaration of modeFuncArray to use the fPtr type instead as well? Like fPtr modeFuncArray[] = { ... }

3CEZVQ Over a year ago

@Someprogrammerdude It is possible too, in this case OP should copy an array. Or OP can left a pointer to array, and then he should dereference a pointer before accessing array elements. All these cases are terrible.

Caleth · Accepted Answer · 2018-04-20 13:36:19Z

Applying @Someprogrammerdude's advice:

#include <iostream>
#include <array>
#include <functional>

void f1 (void) {
  std::cout << "f1" << "\n";
}

void f2 (void) {
  std::cout << "f2" << "\n";
}

using fPtr = std::function<void()>;
using fPtrs = std::array<fPtr, 3>;

class modeChanger {
  public:
    modeChanger (fPtrs funcArray);
    void op ();
  private:
    fPtrs _funcArray;
};

modeChanger::modeChanger (fPtrs funcArray) : _funcArray(funcArray) { }

void modeChanger::op () {
  _funcArray[0]();
  _funcArray[1]();
}   

int main() {
    fPtrs modeFuncArray = {f1, f2, f2};
    modeChanger mode(modeFuncArray);
    modeFuncArray[1]();

    mode.op(); 
    return 0;
}

And thus instead of "hard to declare" C types, we have things as easy as int, and all is well.

Arkady Godlin · Accepted Answer · 2018-04-20 13:32:19Z

0

as you use c++, you should use c++ features and not C, you should use <functional>

#include <iostream>
#include <functional>
void f1(void) {
    std::cout << "f1" << "\n";
}

void f2(void) {
    std::cout << "f2" << "\n";
}

typedef void(*fPtr[3])(void); // simple "[]" gets the compile error

class modeChanger {
public:
    modeChanger(std::function<void(void)>* funcArray);
    void op();
private:
    std::function<void(void)> * _funcArray;
};

modeChanger::modeChanger(std::function<void(void)>* funcArray) {
    _funcArray = funcArray;
}

void modeChanger::op() {
    _funcArray[0]();
    _funcArray[1](); // this line generates a runtime error! Just comment it to get all work
}

std::function<void(void)>  modeFuncArray[]  = { f1, f2, f2 };

modeChanger *mode = new modeChanger(modeFuncArray);

int main() {
    modeFuncArray[1](); // Works fine

    mode->op(); // generates a runtime error
    return 0;
}

answered Apr 20, 2018 at 13:32

Arkady Godlin

5882 silver badges9 bronze badges

2 Comments

M.M Over a year ago

This is a mess IMHO. You say not to "use C features" but your code is full of pointers.

Arkady Godlin Over a year ago

@M.M i wanted to keep the origin code and format for the OP, so he will see the difference of using it.

Collectives™ on Stack Overflow

Pointer to array of pointers to functions

3 Answers 3

2 Comments

Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related