Array of functions

Hello everybody.

While I was looking for a way to call different functions knowing a number
related to the function, I mean n = 1 relates to function() number 1, n = 2 relates to
function() number 2, and so on, I found this article, that is talking about this stuff
but for C++.

Do you know if it can be done in C as well? What would be different between C and C++?

Thanks

Code:

---

Array of Functions
Labels: Arrays, Functions, Miscellaneous, Pointers

In the article Pointers to Function, we saw how pointers can be made
to point at functions and hence can be used to invoke them.

By far the most important use of pointers to functions is to have arrays of functions.
This can be achieved as stated below

You already know that we can have arrays of pointers and pointers
can be made to point at functions.
So combining both we can have array of pointers to functions put differently,
we can have array of functions.

The example program below demonstrates how we can have array of functions;
please note that this concept is mostly used in writing compilers and interpreters,
so you shouldn’t expect the program to do anything serious or useful!

  // Program to demonstrate
  // array of functions
  #include<iostream.h>

  // -- FUNCTION PROTOTYPES --
  void func1();
  void func2();
  void func3();
  void func4();
  void func5();
  // -- ENDS --

  void main()
  {
  // notice the prototype
  void (*ptr[5])();

  // arrays are made to point
  // at the respective functions
  ptr[0]=func1;
  ptr[1]=func2;
  ptr[2]=func3;
  ptr[3]=func4;
  ptr[4]=func5;

  // now the array elements
  // point to different functions
  // which are called just like
  // we access the elements of
  // an array
  for(int i=0;i<5;i++)
    (*ptr[i])();
  }

  // -- FUNCTIONS DEFINITION --
  void func1()
  {
  cout<<"Called Func1!\n";
  }

  void func2()
  {
  cout<<"Called Func2!\n";
  }

  void func3()
  {
  cout<<"Called Func3!\n";
  }

  void func4()
  {
  cout<<"Called Func4!\n";
  }

  void func5()
  {
  cout<<"Called Func5!\n";
  }
  // -- ENDS --

---

Replace all of the cout lines, and try it. Yes, there are function pointers in C.


Quzah.

Quote:

---

Originally Posted by quzah

Replace all of the cout lines, and try it. Yes, there are function pointers in C.


Quzah.

---

And what about:

Code:

---

#include<iostream.h>

---

I have no header with this name in my C compiler.
Maybe

Code:

---

#include <stdio.h>

---

is the substitute?

Thanks

Yes, of course! :)

You can't be afraid to just try these idea's - consider that it took you many times longer to post your question, than it would have taken you to just try it. :(

And that doesn't take into account your time lost while you wait around for an answer.

Learning programming implies, indeed requires, some experimentation on your part.

Quote:

---

Originally Posted by Adak

Yes, of course! :)

You can't be afraid to just try these idea's - consider that it took you many times longer to post your question, than it would have taken you to just try it. :(

And that doesn't take into account your time lost while you wait around for an answer.

Learning programming implies, indeed requires, some experimentation on your part.

---

Thanks Adak.

Well, I'm not afraid to try my ideas, I just enjoy more to interact with people. :-)

Time doesn't matter when you enjoy. I could search a million web sites and find all the
answers I need, and the code, and everything else. But it would be less fun :-(

To be honest I'm not learning programming, I'm just learning C. It is quite different.

Enjoy

Code:

---

#include <stdio.h>

void func1() {        printf("Function 1 Called\n"); }
void func2() {        printf("Function 2 Called\n"); }
void func3() {        printf("Function 3 Called\n"); }

int main(int argc, char *argv[])
{
        static void (*ptr[3])() = {func1,func2,func3};
        int k=0;
        for(k=0;k<3;k++)
                ptr[k]();
        return 0;
}

---

illustrates the C equivalent of how to arrange an array of function pointers.

Note that the example uses void main, but you should not.
Also might be my preference, but I always put & before functions when taking their addresses. Not required, but since since you have to do it for variables, why not functions?

Quote:

---

Originally Posted by Scramble

Code:

---

#include <stdio.h>

void func1() {        printf("Function 1 Called\n"); }
void func2() {        printf("Function 2 Called\n"); }
void func3() {        printf("Function 3 Called\n"); }

int main(int argc, char *argv[])
{
        static void (*ptr[3])() = {func1,func2,func3};
        int k=0;
        for(k=0;k<3;k++)
                ptr[k]();
        return 0;
}

---

illustrates the C equivalent of how to arrange an array of function pointers.

---

Thanks, very useful.

Quote:

---

Originally Posted by Elysia

Note that the example uses void main, but you should not.
Also might be my preference, but I always put & before functions when taking their addresses. Not required, but since since you have to do it for variables, why not functions?

---

You are right, indeed. I just copied the article, I'm not going to use void main() . :-)

Something interesting is one sentence of the article I posted:

Code:

---

please note that this concept is mostly used in writing compilers and interpreters

---

As a matter of fact the use I'm thinking about this function addressing is something
similar to an interpreter. ;-)

Using your suggestions, I modified the routine, and now it works in C:

Code:

---

  // Program to demonstrate
  // array of functions
  #include<stdio.h>

  // -- FUNCTION PROTOTYPES --

  void func1(void);
  void func2(void);
  void func3(void);
  void func4(void);
  void func5(void);
  // -- ENDS --

  int main(void)
  {
  // notice the prototype

  void (*ptr[5])();

  // arrays are made to point
  // at the respective functions

  ptr[0]=&func1;
  ptr[1]=&func2;
  ptr[2]=&func3;
  ptr[3]=&func4;
  ptr[4]=&func5;

  // now the array elements
  // point to different functions
  // which are called just like
  // we access the elements of
  // an array

  for(int i=0;i<5;i++)
    ptr[i]();
  return 0;
  }

  // -- FUNCTIONS DEFINITION --

  void func1(void)
  {
  printf("Called Func1!\n");
  }

  void func2(void)
  {
  printf("Called Func2!\n");
  }

  void func3(void)
  {
  printf("Called Func3!\n");
  }

  void func4(void)
  {
  printf("Called Func4!\n");
  }

  void func5(void)
  {
  printf("Called Func5!\n");
  }

---

and the output:

Code:

---

Called Func1!
Called Func2!
Called Func3!
Called Func4!
Called Func5!
Press any key to continue...

---

Thanks everybody

You may also want to know of a trick to simplify the code.
Function pointer declarations are horrible, and even more so if you're going to return them from a function. Thankfully, we can abstract this by creating a type alias:

typedef void (FncPtr_t)();
FncPtr_t* ptr[5];

Looks much better, don't you think?

Quote:

---

Originally Posted by Elysia

You may also want to know of a trick to simplify the code.
Function pointer declarations are horrible, and even more so if you're going to return them from a function. Thankfully, we can abstract this by creating a type alias:

typedef void (FncPtr_t)();
FncPtr_t* ptr[5];

Looks much better, don't you think?

---

Good, I'll consider this option as well, thanks.

Now let's move one step further. What if I'd like to declare an array of functions
each taking 2 char parameters? Can anyone show me some implementation of this?

Would it be something like:

Code:

---

typedef void (FncPtr_t)(char, char);
FncPtr_t* ptr[5];

---

or what?

Thanks

Yes, that's correct.

OK.

Now I've tried to implement the parameters, based on the previous version.
Next I'll try the version proposed by Elysia.

Code:

---

  // Program to demonstrate
  // array of functions
  #include<stdio.h>

  // -- FUNCTION PROTOTYPES --

  void func1(char, char);
  void func2(char, char);
  void func3(char, char);
  void func4(char, char);
  void func5(char, char);
  // -- ENDS --

  int main(void)
  {
  // notice the prototype

  void (*ptr[5])(char, char);

  // arrays are made to point
  // at the respective functions

  ptr[0]=&func1;
  ptr[1]=&func2;
  ptr[2]=&func3;
  ptr[3]=&func4;
  ptr[4]=&func5;

  // now the array elements
  // point to different functions
  // which are called just like
  // we access the elements of
  // an array

  for(int i=0;i<5;i++)
    ptr[i]('A',' ');
  return 0;
  }

  // -- FUNCTIONS DEFINITION --

  void func1(char token, char times)
  {
  printf("Called Func1!\n");
  printf("Token = \'%c\' - to repeat %d times\n",token,times);
  }

  void func2(char token, char times)
  {
  printf("Called Func2!\n");
  printf("Token = \'%c\' - to repeat %d times incremented by 1\n",token,times);
  }

  void func3(char token, char times)
  {
  printf("Called Func3!\n");
  printf("Token = \'%c\' - to repeat %d times doubled\n",token,times);
  }

  void func4(char token, char times )
  {
  printf("Called Func4!\n");
  printf("Token = \'%c\' - to repeat %d times doubled except the last time\n",token,times);
  }

  void func5(char token, char times)
  {
  printf("Called Func5!\n");
  printf("Token = \'%c\' - to repeat %d times tripled\n",token,times);
  }

---

and the output:

Code:

---

Called Func1!
Token = 'A' - to repeat 32 times
Called Func2!
Token = 'A' - to repeat 32 times incremented by 1
Called Func3!
Token = 'A' - to repeat 32 times doubled
Called Func4!
Token = 'A' - to repeat 32 times doubled except the last time
Called Func5!
Token = 'A' - to repeat 32 times tripled
Press any key to continue...

---

You are printing a char with %d. This is obviously a bad idea™.
Either you pass an int or you cast the char to an int before passing it to printf.

Quote:

---

Originally Posted by Elysia

You are printing a char with %d. This is obviously a bad idea™.
Either you pass an int or you cast the char to an int before passing it to printf.

---

According to what I've read, chars have a double nature, and can
be used in both ways. What are your comments related to? I
mean what risk you are pointing to?

Yes, they can be used in many ways. It is a storage of 1 byte, but it's usually used to represent characters.
But that's not the problem. You can safely pass <= 255 to it, but you are lying to printf by saying you are passing an int:
printf("Token = \'%c\' - to repeat %d times tripled\n",token,times);
Either you pass an int from the beginning:

Code:

---

  void func5(char token, int times)
{
    printf("Called Func5!\n");
    printf("Token = \'%c\' - to repeat %d times tripled\n",token,times);
}

---

Or you cast the char to an int:

Code:

---

  void func5(char token, char times)
{
    printf("Called Func5!\n");
    printf("Token = \'%c\' - to repeat %d times tripled\n",token,(int)times);
}

---

The format specifier is there to tell printf what types you are passing to it, so you can obviously not lie. That will cause undefined behavior.

There's not anything wrong with using printf %d on a char (it is perfectly safe and acceptable), however, stylistically it is just silly to use a char to pass around an int:

Code:

---

void func2(char token, char times)

---

should be:

Code:

---

void func2(char token, int times)

---

Unless there is a reason you need a char there.

Quote:

---

Originally Posted by MK27

There's not really anything wrong with using %d on a char, however, stylistically it is just silly to use a char to pass around an int:

Code:

---

void func2(char token, char times)

---

should be:

Code:

---

void func2(char token, int times)

---

Unless there is a reason you need a char there.

---

Well I have reasons indeed, because the pgm I'm dreaming about is
doing some sort of compression, so if I use 1 byte to represent numbers from 0 to 255
instead of an integer, I spare 3 bytes.

Quote:

---

Originally Posted by Elysia

Yes, they can be used in many ways. It is a storage of 1 byte, but it's usually used to represent characters.
But that's not the problem. You can safely pass <= 255 to it, but you are lying to printf by saying you are passing an int:
printf("Token = \'%c\' - to repeat %d times tripled\n",token,times);
Either you pass an int from the beginning:

Code:

---

  void func5(char token, int times)
{
    printf("Called Func5!\n");
    printf("Token = \'%c\' - to repeat %d times tripled\n",token,times);
}

---

Or you cast the char to an int:

Code:

---

  void func5(char token, char times)
{
    printf("Called Func5!\n");
    printf("Token = \'%c\' - to repeat %d times tripled\n",token,(int)times);
}

---

The format specifier is there to tell printf what types you are passing to it, so you can obviously not lie. That will cause undefined behavior.

---

Well it actually works, and nothing I've read so far suggests not
using chars in this way as well. Of course if problems could arise, I'd prefer
to typecast to int in order to save the original compressing idea.

You never notice undefined behavior and implementation defined behavior until it's too late. One second it works, the next it breaks. And you can get different results on different compilers and platforms. Not a good idea.

Quote:

---

Originally Posted by Elysia

You never notice undefined behavior and implementation defined behavior until it's too late. One second it works, the next it breaks. And you can get different results on different compilers and platforms. Not a good idea.

---

Are you sure? I've only read ANSI C manuals so far...

Quote:

---

Originally Posted by frktons

Well I have reasons indeed, because the pgm I'm dreaming about is
doing some sort of compression, so if I use 1 byte to represent numbers from 0 to 255
instead of an integer, I spare 3 bytes.

---

Yes, I used to believe using a short int (2 bytes) was better than using an int because of this.

In fact, it is not true. Compilers and desktop processors tend to deal with things in units of 4 bytes (32-bits) or 8 bytes (64-bits). Anything smaller than this must be padded up with zeros when the processor works with the value, meaning an int is the most efficient unit, because no additional padding and chopping operations are necessary.

WRT to just storage, odd numbers don't work either, and unless the compiler finds a clever way to segment stuff, it will probably pad this out to.

In other words, you think you are saving space but you are probably not, and the assembly level code for your program, created by the compiler, will be less efficient, and/or the processor will have to resort to additional (time wasting operations) to deal with the single byte.

You could place both chars into a single int and bitshift them out, that might be a slight optimization, but I think most people would consider it pointless.

Quote:

---

Originally Posted by Elysia

You never notice undefined behavior and implementation defined behavior until it's too late.

---

In fact, printf'ing a char with %d is not undefined behavior, it's secured by the standard. So this logic does not apply here.

Promotion rules? What do they say?
Btw, regardless of whether it's defined or not, I would say I recommend it anyway to avoid confusion and raised eye browns.
Also note that chars may not be as fast as ints, but they will take up less space in memory. Regardless of how the CPU does it, it will take less memory storage, because the CPU has to pad it, not C.
And the performance impact from ints vs chars is negligible.
On x64 systems, it's even worse because each number has to be 64 bits. Are you going to use a 64-bit type instead? 8 bytes vs 1? A lot of wasted memory there.

Quote:

---

Originally Posted by MK27

Yes, I used to believe using a short int (2 bytes) was better than using an int because of this.

In fact, it is not true. Compilers and desktop processors tend to deal with things in units of 4 bytes (32-bits) or 8 bytes (64-bits). Anything smaller than this must be padded up with zeros when the processor works with the value, meaning an int is the most efficient unit, because no additional padding and chopping operations are necessary.

WRT to just storage, odd numbers don't work either, and unless the compiler finds a clever way to segment stuff, it will probably pad this out to.

In other words, you think you are saving space but you are probably not, and the assembly level code for your program, created by the compiler, will be less efficient, and/or the processor will have to resort to additional (time wasting operations) to deal with the single byte.

You could place both chars into a single int and bitshift them out, that might be a slight optimization, but I think most people would consider it pointless.

---

You are right, I am aware of the Assembly level coding that the compilers do.
But the implementation I've in my mind is just to store compressed data inside
variables inside the program, and when I read them one byte at a time, I'm just
using low bytes like AL or BL or CL and so on registers. Probably the inner part
of the routine dealing with these codes will be written in Assembly, to take advantage
of the speed and capacity of the low level coding. I don't have any problem of portability
in my mind because the pgm will just run on my pc Win 7 Ultimate 64 bit.

Quote:

---

Promotion rules? What do they say?
Btw, regardless of whether it's defined or not, I would say I recommend it anyway to avoid
confusion and raised eye browns.
Also note that chars may not be as fast as ints, but they will take up less space in memory.
Regardless of how the CPU does it, it will take less memory storage, because the CPU has to pad it, not C.
And the performance impact from ints vs chars is negligible.
On x64 systems, it's even worse because each number has to be 64 bits. Are you going to use a 64-bit type
instead? 8 bytes vs 1? A lot of wasted memory there.

---

Please read the objective the pgm will have, I understand all these recommendations and
I'd probably say the same thing. But this is a specific case. I need to compress data inside
a variable inside a program.

Quote:

---

Originally Posted by Elysia

Promotion rules? What do they say?

---

That the char is promoted to an int -- eg, you could use %hhd in which case it's promoted to an int anyway, then converted to a char, so this is sort of pointless. It's the same as:

Code:

---

char a, b;
a = a + b;

---

Arithmetic operations are not performed on chars. They default to ints in this case (which is another example of how using a char in place of an int only involves more work, not less), then the result is truncated into a char.

Quote:

---

Originally Posted by MK27

That the char is promoted to an int -- eg, you could use %hhd in which case it's promoted to an int anyway, then converted to a char, so this is sort of pointless. It's the same as:

Code:

---

char a, b;
a = a + b;

---

Arithmetic operations are not performed on chars. They default to ints in this case (which is another example of how using a char in place of an int only involves more work, not less), then the result is truncated into a char.

---

I'm NOT going to use char to perform arithmetic, or anything stupid. Please believe me. :-)

Quote:

---

Originally Posted by frktons

I'm NOT going to use char to perform arithmetic, or anything stupid. Please believe me. :-)

---

There is nothing stupid about performing arithmetic on chars, it's allowed, normal, sometimes necessary. The point is it incurrs a time penalty for handling a single byte. The EXACT SAME THING IS TRUE with regatd to using printf(%d) on a char. It is exactly the same penalty. It is not undefined or unsafe, it's just less efficient. You are not using an 8-bit processor. You are using a 32 or 64 bit processor.

So as I tried to explain before, you are not saving anything this way. You are actually de-optimizing (the opposite of your intent).

I still have old code where I used short ints for stuff because I thought that was "saving", but it's not! It's WASTE.

Quote:

---

Originally Posted by MK27

There is nothing stupid about performing arithmetic on chars, it's allowed, normal, sometimes necessary. The point is it incurrs a time penalty for handling a single byte. The EXACT SAME THING IS TRUE with regatd to using printf(%d) on a char. It is exactly the same penalty. It is not undefined or unsafe, it's just less efficient. You are not using an 8-bit processor. You are using a 32 or 64 bit processor.

So as I tried to explain before, you are not saving anything this way. You are actually de-optimizing (the opposite of your intent).

I still have old code where I used short ints for stuff because I thought that was "saving", but it's not! It's WASTE.

---

Of course, and I repeat I'm well aware of that.

At the Assembly level dealing with 1 byte is possible but less efficient
than dealing with 4 or 8 bytes at a time like in any other language. But there are
situations in which you HAVE to work at a byte level or even at a bit level.
It just depends on what you have to do. Compressing data is not the same of
doing general programming, it is a specific task with specific requirements.
The main goal is reducing space, the second one is doing it at a decent speed and in
a safe non destructive way.

Quote:

---

Originally Posted by frktons

But there are
situations in which you HAVE to work at a byte level or even at a bit level.
It just depends on what you have to do.

---

It's your program, but the code you posted does not need to use a char in place of an int. So in terms of "what you have to do" there, you should be using an int.

Quote:

---

Originally Posted by MK27

It's your program, but the code you posted does not need to use a char in place of an int. So in terms of "what you have to do" there, you should be using an int.

---

I agree, so this would be better, I suppose:

Code:

---

// Program to demonstrate
  // array of functions
  #include<stdio.h>

  // -- FUNCTION PROTOTYPES --

  void func1(char,int);
  void func2(char, int);
  void func3(char,int);
  void func4(char,int);
  void func5(char, int);
  // -- ENDS --

  int main(void)
  {
  // notice the prototype

  void (*ptr[5])(char, int);

  // arrays are made to point
  // at the respective functions

  ptr[0]=&func1;
  ptr[1]=&func2;
  ptr[2]=&func3;
  ptr[3]=&func4;
  ptr[4]=&func5;

  // now the array elements
  // point to different functions
  // which are called just like
  // we access the elements of
  // an array

  for(int i=0;i<5;i++)
    ptr[i]('A',(int) ' ');
  return 0;
  }

  // -- FUNCTIONS DEFINITION --

  void func1(char token, int times)
  {
  printf("Called Func1!\n");
  printf("Token = \'%c\' - to repeat %d times\n",token,times);
  }

  void func2(char token, int times)
  {
  printf("Called Func2!\n");
  printf("Token = \'%c\' - to repeat %d times incremented by 1\n",token,times);
  }

  void func3(char token,int times)
  {
  printf("Called Func3!\n");
  printf("Token = \'%c\' - to repeat %d times doubled\n",token,times);
  }

  void func4(char token, int times )
  {
  printf("Called Func4!\n");
  printf("Token = \'%c\' - to repeat %d times doubled except the last time\n",token,times);
  }

  void func5(char token, int times)
  {
  printf("Called Func5!\n");
  printf("Token = \'%c\' - to repeat %d times tripled\n",token,times);
  }

---