Is it possible to create one function instead two functions of same purpose but different argument type? (Can I remove duplicate code?)

Question

Is it possible to create one function instead two functions of same purpose but different argument type?

I have two functions written in C, they convert image from RGB to HSV:

void png_rgb2hsv(pPNG_DATA data);
void jpg_rgb2hsv(pJPEG_DATA data);

they do exactly same thing: they take data->row_pointers and cycle it in a loop data->height times. Then it convert the values referred by data->row_pointers. This is how it works. But the only difference is that the data structures use different types. It seems to me senseless to use two functions for same thing. Especially when I would add more functions for more color spaces.

How this problem of program design is solved in practice in C?

Update: Most of readers didn't understand the question. I did not asked about overloading. It was question about design. I ask if is it possible to remove redundant function, "redundant" code. Because both functions are using same code, do the same thing, but the types in the function argument are different because one type is from libjpeg and the second type is from libpng. What I found is that it is not possible because it would mean use one variable for two different types.

Answer 1

Use a generic macro:

void png_rgb2hsv(pPNG_DATA data);
void jpg_rgb2hsv(pJPEG_DATA data);

#define rgb2hsv(X) _Generic((X), pPNG_DATA: png_rgb2hsv, pJPEG_DATA: jpg_rgb2hsv)(X)

(If your compiler is too old and does not suport this trick (or you don't want to use it for some reason), then looks like there is no way to have 2 functions with same name and different argument type. Then, you would need to choose another solution.)

Update:

I misunderstood OP's question. If you want to create a single function for both types, you should do something like this:

void rgb2hsv_(Something *row_pointers, int height) // any member that you need goes here
{
    /* your code */
}

#define rgb2hsv(obj) \
do { \
_Generic((obj), pPNG_DATA: pPNG_DATA, pJPEG_DATA: pJPEG_DATA) tmp = (obj); \
    rgb2hsv_(tmp->row_pointers, tmp->height /*again, every member that you need should be stated here*/) \
} while (0)

Also, if pJPEG_DATA and pPNG_DATA have absolutely same internal layout (it means their members have same type and they are listed in the same order), you can try this: (it's not as safe as previous one, but at least it does not look like a bad hack)

void rgb2hsv(void *ptr)
{
    pPNG_DATA data = (pPNG_DATA *) ptr; // it does not matter which of 2 types you use here
    /* put your code that uses `data` here */
}

But keep in mind that if you swap 2 members in any of these structs or change their internal structure in any way, then this thing may no longer work.

( Also, you should know: these 2 techniques are just tricky workarounds to get a desired result. Best way is just to pass each needed member as separate argument and don't do this macro kung fu )

Answer 2

Void pointers are compatible with pointer to any object. You can use void* and add a "type" parameter.

void data2hsv(void *data, int datatype) {
    if (datatype == 0) {
        /* use png */
    } else {
        /* use jpg */
    }
}

Edit: lying to the compiler

void data2hsv(void *data) {
    pPNG_DATA source = data; // if data is of pJPG_DATA type 
                             // compiler will not catch the error
    /* use source as if it was pPNG_DATA */
}

Answer 3

There are mainly two different ways to handle this. You create a struct which contains the image and also a tag what the data is, something like this:

struct img{
    char *filetype;
    void *data;
};

And then you create a function which checks filetype and call what ever function you want.

Or you create a struct with function pointers to what ever functions you want to use, something like this:

struct imgfuns{
    void (*rgb2hsv)(void *);
};

struct imgfuns *init_struct(void)
{
    struct imgfuns *funs = malloc(sizeof(*funs));
    if(funs == NULL)
        return NULL;
    if(png...)
        funs->rgb2hsv = png_rgb2hsv;
    else if(jpg...)
        funs->rgb2hsv = jpg_rgb2hsv;
    return funs;
}

int main(int argc, char *argv[])
{
    struct imgfuns *funs;
    funs = init_struct();
    if(funs == NULL)
      exit(1);
    /* get data from somewhere */
    funs->rgb2hsv(data);
    free(funs);
    return 0;
}

But it can be a pain if you need to use many different functions as you need to map them for each function. But you will get cleaner code and you can handle all formats in one place instead of creating wrapper functions for each file format.

More info can be found here: How do function pointers in C work?

Answer 4

That's not possible in C, but in many other programming languages, such as C++, it is possible.

However, there are some tricks around that limitation in C, see this question for more information.

One common practice in C is to put the type in the function name, as in your example.

Answer 5

The followoing uses an additional parameter to inform the function what type of image data is passed:

void rgb2hsv(void *data, int data_type)
{
    char *row, *pix;
    switch (data_type) {
        case JPG: row= (pJPEG_DATA data)->row; break;
        case PNG: row= (pPNG_DATA  data)->row; break;
    }
    ....

Answer 6

You cannot overload functions in C, but you can organize your code to make it optimal. I would create a function for rgb2hsv and that would get a void * type of parameter, would determine the type and use it, handling all possible cases. And you should use only this function. On lower levels you still duplicate your function, on higher level you will not have to call two separate functions. This would simplify usage.