Is there a way to define a "common" structure for multiple parameter numbers and types

Question

I would like to create a common structure that I may use to pass parameters of multiple lengths and types into different functions.

As an example, consider the following structure:

typedef struct _list_t {
    int ID;
    char *fmt;
    int nparams;
} list_t;
list_t infoList[100]; //this will be pre-populated with the operations my app offers 


typedef struct _common {
    int ID;
    char *params;
} common;

A variable size function is used to pass in the parameters given the format is already populated:

int Vfunc(common * c, ...) {
    va_list args;
    va_start(args, c);
    
    //code to search for ID in infoList and fetch its fmt
    char params_buff[100]; //max params is 100
    vsprintf(str_params, fmt, args);

    va_end(args);

    c->params = (char *)malloc(sizeof(char)*(strlen(params_buff)+1));
    strncpy(c->params, params_buff, strlen(params_buff)+1);
}
int execute(common * c) { 
    if (c->ID == 1) { //add 2 numbers
        int x, y; // i expect 2 numbers 
        //code to find ID in infoList and fetch its fmt
        sscanf(c->params, fmt, &x, &y);
    
        return (x + y);
    }
    else if (c->ID == 2) {
    //do another operation, i expect an unsigned char array?
    }
    
}

Main program will look somewhat like this:

int main()
{
    common c;
    c.ID = 1;

    Vfunc(&c, 12, 2);
    
    execute(&c);
    
    return 0;
}

Now I can pass in the structure to any function, which will deal with the parameters appropriately. However I do not see a way to have unsigned char[] as one of the parameters since unsigned char arrays do not have a "format". The format of a char[] would be %s. Basically I want to pass in some raw data through this structure.

Is there a way to do this or a better implementation to fulfill the goal?

EDIT:

It seems that the questions goal is unclear. Say my application can provide arithmetic operations (like a calculator). Say a user of my application wants to add 2 numbers. All I want them to do is fill in this common structure, then pass it into lets say a function to get it executed. All the ID's of the operations will be known from lets say a manual, so the user will know how many parameters they can pass and what ID does what. As the app owner i will be filling infoList with the ID's I offer.

So this is just to give you an idea of what I mean by a "common structure". It can be implemented in other ways too, maybe you have a better way. But my goal is for the implementation to be able to pass in an unsigned char array. Can I do that?

Answer 1

As I understand your question, you want to save all argument values in a text string so that the values can be reconstructed later using sscanf. Further, you want to be able to handle array-of-number, e.g. an array of unsigned char.

And you ask:

Is there a way to do this

For your idea to work, it's required that sscanf can parse (aka match) the type of data that you want to use in your program. And - as you write in the question - scanf can't parse arrays-of-numbers. So the answer is:

No, it can't be done with standard functions.

So if you want to be able to handle arrays-of-number, you'll have to write your own scan-function. This includes

1. selection of a conversion specifier to tell the code to scan for an array (e.g. %b),
2. select a text-format for the array (e.g. "{1, 2, 3}")
3. a way to store the array-data and the size, e.g. struct {unsiged char* p; size_t nb_elements;}.

Further, you'll have the same problem with vsprintf. Again you need to write your own function.

EDIT

One alternative (that I don't really like myself) is to store pointer values. That is - instead of storing the array values in the string params you can store a pointer to the array.

The upside of that approach is that you can use the standard functions.

The downside is that the caller must ensure that the array exists until execute has been called.

In other words:

unsigned char auc[] = {1, 2, 3};
Vfunc(&c, auc);
execute(&c);

would be fine but

Vfunc(&c, (unsigned char[]){1, 2, 3});
execute(&c);

would compile but fail at run time.

And - as always with arrays in C - you may need an extra argument for the number of array elements.

Example code for this "save as pointer" approach could be:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>

typedef struct _common {
    int ID;
    char *params;
} common;

void Vfunc(common * c, ...) {
    va_list args;
    va_start(args, c);

    //code to search for ID in infoList and fetch its fmt
    // For this example just use a fixed fmt
    char fmt[] ="%p %zu";


    char params_buff[100]; //max params is 100
    vsprintf(params_buff, fmt, args);

    va_end(args);

    c->params = (char *)malloc(sizeof(char)*(strlen(params_buff)+1));
    strncpy(c->params, params_buff, strlen(params_buff)+1);
}

int execute(common * c)
{
    if (c->ID == 1) {
      // expect pointer and number of array elements
      unsigned char* a;
      size_t nbe;

      //code to find ID in infoList and fetch its fmt
      // For this example just use a fixed fmt
      char fmt[] ="%p %zu";

      if (sscanf(c->params, fmt, &a, &nbe) != 2) exit(1);

      // Calculate average
      int sum = 0;
      for (size_t i = 0; i < nbe; ++i) sum += a[i];
      return sum;
    }

    return 0;
}

int main(void)
{
  common c;
  c.ID = 1;

  unsigned char auc[] = {1, 2, 3, 4, 5, 6};

  Vfunc(&c, auc, sizeof auc / sizeof auc[0]);

  printf("The saved params is \"%s\"\n", c.params);
  printf("Sum of array elements are %d\n", execute(&c));

  return 0;
}

Possible Output

The saved params is "0xffffcc0a 6"
Sum of array elements are 21

Notice that it's not the array data that is saved but a pointer value.

Answer 2

I think what you want from your description is likely a union of structs, with the 1st member of the union being an enumerator that defines the type of the structure in use, which is how polymorphism is often accomplished in C. Look at the X11 headers for a giant example of Xevents

A trivial example:

//define our types
typedef enum  {
chicken,
cow,
no_animals_defined
} animal;

typedef struct {
animal species;
int foo;
char bar[20];
} s_chicken;

typedef struct {
animal species;
double foo;
double chew;
char bar[20];
} s_cow;

typedef union {
animal species; // we need this so the receiving function can identify the type.
s_chicken chicken ;
s_cow cow ;
} s_any_species;

now, this struct may be passed to a function and take on either identity. A receiving function of a type s_any_species may do to de-reference.

void myfunc (s_any_species any_species)
{
if (any_species.species == chicken)
   any_species.chicken.foo=1 ;
}

Arrays of function pointers are preferable to long if else sequences here, but either will work

Answer 3

I have read the problem once again, and find out that it's much simpler than you've described.

According to your statement, you already know about the type and order of data retrieval in execute() function. This make this problem much easier.

I must say, this problem is a bit difficult to solve in c, cause c can't resolve type at runtime or dynamically cast type at runtime. c must know all the types before hand i.e. at compile time.

Now, that said, c provides a way to handle variable length arguments. And that's a advantage.

So, what we've to do is:

1. cache all arguments from variable length arguments i.e. va_list.
2. and, provide a way to retrieve provided arguments from that cache.

At first, I am going to show you how to retrieve elements from cache if you know the type. We'll do it using a macro. I've named it sarah_next(). Well, after all, I've to write it because of you. You can name it as you want. It's definition is given below:

#define sarah_next(cache, type)                        \
        (((cache) = (cache) + sizeof(type)),           \
        *((type*) (char *) ((cache) - sizeof(type))))

So, in simple words, sarah_next() retrieve the next element from cache and cast it to type.

Now, let's discuss the first problem, where we've to cache all arguments from va_list. You can do it easily by writing as follows:

void *cache = malloc(sizeof(char) * cacheSize);
// itr is an iterator, which iterates over cache
char *itr = (char *)cache;
// now, you can do
*(type *)itr = va_arg(buf, type);
// and then
itr += sizeof(type);

Another, point I would like to discuss is, I've used type hint to determine cache size. For that I've used a function getSize(). You would understand if you just look at it(also note: this gives you the ability to use your own custom type):

// getSize() is a function that returns type size based on type hint
size_t getSize(char type) {
    if(type == 's') {
        return sizeof(char *);
    }
    if(type == 'c') {
        return sizeof(char);
    }
    if(type == 'i') {
        return sizeof(int);
    }
    if(type == 'u') { // 'u' represents 'unsigned char'
        return sizeof(unsigned char);
    }
    if(type == 'x') { // let's, say 'x' represents 'unsigned char *'
        return sizeof(unsigned char *);
    }
    // you can add your own custom type here
    // also note: you can easily use 'unsigned char'
    //            use something like 'u' to represent 'unsigned char'
    //            and you're done
    // if type is not recognized, then
    printf("error: unknown type while trying to retrieve type size\n");
    exit(1);
}

Ok, I guess, the ideas are complete. Before moving on try to grasp the ideas properly.

Now, let me provide the full source code:

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

// note: it is the most fundamental part of this solution
//       'sarah_next' is a macro, that
//       returns *(type *)buf means a value of type "type", and also
//       increments 'buf' by 'sizeof(type)', so that
//       it may target next element
//       'sarah_next' is used to retrieve data from task cache

// I've named it after you, you may choose to name it as you wish
#define sarah_next(cache, type)                        \
        (((cache) = (cache) + sizeof(type)),           \
        *((type*) (char *) ((cache) - sizeof(type))))


// defining pool size for task pool
#define POOL_SIZE 1024


// notice: getSize() has been updated to support unsigned char and unsigned char *
// getSize() is a function that returns type size based on type hint
size_t getSize(char type) {
    if(type == 's') {
        return sizeof(char *);
    }
    if(type == 'c') {
        return sizeof(char);
    }
    if(type == 'i') {
        return sizeof(int);
    }
    if(type == 'u') { // 'u' represents 'unsigned char'
        return sizeof(unsigned char);
    }
    if(type == 'x') { // let's, say 'x' represents 'unsigned char *'
        return sizeof(unsigned char *);
    }
    // you can add your own custom type here
    // also note: you can easily use 'unsigned char'
    //            use something like 'u' to represent 'unsigned char'
    //            and you're done
    // if type is not recognized, then
    printf("error: unknown type while trying to retrieve type size\n");
    exit(1);
}


typedef struct __task {
    int id;
    void *cache;
} Task;

// notice: constructTask has been updated to support unsigned char and unsigned char *
// note: here, types contains type hint
Task *constructTask(int id, char *types, ...) {
    // determine the size of task cache
    int cacheSize = 0;
    for(int i=0; types[i]; i++) {
        cacheSize += getSize(types[i]);
    }
    // allocate memory for task cache
    void *cache = malloc(sizeof(char) * cacheSize);
    
    va_list buf;
    va_start(buf, types);
    
    // itr is an iterator, which iterates over cache
    char *itr = (char *)cache;
    for(int i=0; types[i]; i++) {
        if(types[i] == 's') {
            *(char **)itr = va_arg(buf, char *);

        } else if(types[i] == 'x') { // added support for 'unsigned char *'
            *(unsigned char **)itr = va_arg(buf, unsigned char *);

        } else if(types[i] == 'c') {
            // notice: i used 'int' not 'char'
            // cause: compiler-warning: 'char' is promoted to 'int' when passed through '...'
            // also note: this promotion helps with 'unsigned char'
            *(char *)itr = (char)va_arg(buf, int); // so cast it to char

        } else if(types[i] == 'u') { // added support 'unsigned char'
            // notice: i used 'int' not 'unsigned char'
            // cause: compiler-warning: 'unsigned char' is promoted to 'int' when passed through '...'
            // also note: this promotion helps with 'unsigned char'
            *(unsigned char *)itr = (unsigned char)va_arg(buf, int); // so cast it to unsigned char

        } else if(types[i] == 'i') {
            *(int *)itr = va_arg(buf, int);

        }
        // it won't come to else, cause getSize() would
        // caught the type error first and exit the program
        itr += getSize(types[i]);
    }

    va_end(buf);

    // now, construct task
    Task *task = malloc(sizeof(Task));
    task->id = id;
    task->cache = cache;
    // and return it
    return task;
}

// destroyTask is a function that frees memory of task cache and task
void destroyTask(Task *task) {
    free(task->cache);
    free(task);
}

// notice: that 'task->id == 4' processing part
// it is equivalant to your 'execute()' function
int taskProcessor(Task *task) {
    // define ret i.e. return value
    int ret = 999; // by default it is some code value, that says error

    // note: you already know, what type is required in a task
    if(task->id == 1) {
        // note: see usage of 'sarah_next()'
        int x = sarah_next(task->cache, int);
        int y = sarah_next(task->cache, int);

        ret = x + y;

    } else if(task->id == 2) {
        char *name = sarah_next(task->cache, char *);
        if(strcmp(name, "sarah") == 0) {
            ret = 0; // first name
        } else if (strcmp(name, "cartenz") == 0) {
            ret = 1; // last name
        } else {
            ret = -1; // name not matched
        }
    } else if(task->id == 3) {
        int x = sarah_next(task->cache, int);
        char *name = sarah_next(task->cache, char *);
        int y = sarah_next(task->cache, int);

        printf("%d %s %d\n", x, name, y); // notice: we've been able to retrieve
        // both string(i.e. char *) and int
        // you can also see for ch and int, but i can assure you, it works

        ret = x + y;

    } else if(task->id == 4) { // working with 'unsigned char *'
        int a = sarah_next(task->cache, int);
        unsigned char *x = sarah_next(task->cache, unsigned char *); // cast to unsigned char *
        // char *x = sarah_next(task->cache, char *); // this won't work, would give wrong result
        int b = sarah_next(task->cache, int);

        printf("working with 'unsigned char *':");
        for(int i=0; x[i]; i++) {
            printf(" %d", x[i]); // checking if proper value is returned, that's why using 'integer'
        }
        printf("\n");

        ret = a + b;
    } else {
        printf("task id not recognized\n");
    }

    return ret;
}


int main() {
    Task *taskPool[POOL_SIZE];

    int taskCnt = 0;

    taskPool[taskCnt++] = constructTask(1, "ii", 20, 30); // it would return 50
    taskPool[taskCnt++] = constructTask(1, "ii", 50, 70); // it would return 120
    taskPool[taskCnt++] = constructTask(2, "s", "sarah"); // it would return 0
    taskPool[taskCnt++] = constructTask(2, "s", "cartenz"); // it would return 1
    taskPool[taskCnt++] = constructTask(2, "s", "reyad"); // it would return -1
    taskPool[taskCnt++] = constructTask(3, "isi", 40, "sarah", 60); // it would print [40 sarah 60] and return 100

    // notice: I've added an exmaple to showcase the use of unsigned char *
    // also notice: i'm using value greater than 127, cause
    // in most compiler(those treat char as signed) char supports only upto 127
    unsigned char x[] = {231, 245, 120, 255, 0}; // 0 is for passing 'NULL CHAR' at the end of string
    // 'x' is used to represent 'unsigned char *'
    taskPool[taskCnt++] = constructTask(4, "ixi", 33, x, 789); // it would print ['working with unsigned char *': 231 245 120 255] and return 822
    // note: if you used 'char *' cast to retrieve from 'cache'(using a compiler which treats char as signed), then
    //       it would print [-25 -11 120 -1] instead of [231 245 120 255]
    //       i guess, that makes it clear that you can perfectly use 'unsigned char *'

    for(int i=0; i<taskCnt; i++) {
        printf("task(%d): %d\n", i+1, taskProcessor(taskPool[i]));
        printf("\n");
    }

    // at last destroy all tasks
    for(int i=0; i<taskCnt; i++) {
        destroyTask(taskPool[i]);
    }

    return 0;
}

The output is:

// notice the updated output
task(1): 50                                        
                                                   
task(2): 120                                       
                                                   
task(3): 0                                         
                                                   
task(4): 1                                         
                                                   
task(5): -1                                        
                                                   
40 sarah 60                                        
task(6): 100                                       
                                                   
working with 'unsigned char *': 231 245 120 255    
task(7): 822

So, you may be wondering, what advantage it may create over your given solution. Well, first of all you don't have to use %s %d etc. do determine format, which is not easy to change or create for each task and you've write a lot may be(for each task, you may have to write different fmt), and you don't have use vsprintf etc... which only deals with builtin types.

And the second and great point is, you can use your own custom type. Declare a struct type of your own and you can use. And it is also easy to add new type.

update:

I've forgot to mention another advantage, you can also use unsigned char with it. see, the updated getSize() function. you can use 'u' symbol for unsigned char, and as unsigned char is promoted to int, you can just cast it to (unsigned char) and done...

update-2(support for unsigned char *):

I have updated the code to support unsigned char and unsigned char *. To support new type, the functions, those you need to update, are getSize() and constructTask(). Compare the previous code and the newly updated code...you'll understand how to add new types(you can also add custom types of your own).

Also, take a look at task->id == 4 part in taskProcessor() function. I've added this to showcase the usage of unsigned char *. Hope this clears everything.

If you've any question, then ask me in the comment...

Answer 4

I take you to be asking about conveying a sequence of objects a varying type to a function. As a special detail, you want the function to receive only one actual argument, but this is not particularly significant because it is always possible to convert a function that takes multiple arguments into another that takes only one by wrapping the multiple parameters in a corresponding structure. I furthermore take the example Vfunc() code's usage of vsprintf() to be an implementation detail, as opposed to an essential component of the required solution.

In that case, notwithstanding my grave doubts about the usefulness of what you seem to want, as a C programming exercise it does not appear to be that difficult. The basic idea you seem to be looking for is called a tagged union. It goes by other names, too, but that one matches up well with the relevant C-language concepts and keywords. The central idea is that you define a type that can hold objects of various other types, one at a time, and that carries an additional member that identifies which type each instance currently holds.

For example:

enum tag { TAG_INT, TAG_DOUBLE, TAG_CHAR_PTR };
union tagged {
    struct {
        enum tag tag;
        // no data -- this explicitly gives generic access to the tag
    } as_any;
    struct {
        enum tag tag;
        int data;
    } as_int;
    struct {
        enum tag tag;
        double data;
    } as_double;
    struct {
        enum tag tag;
        char *data;
    } as_char_ptr;
    // etc.
};

You could then combine that with a simple list wrapper:

struct arg_list {
    unsigned num;
    union tagged *args;
};

Then, given a function such as this:

int foo(char *s, double d) {
    char[16] buffer;
    sprintf(buffer, "%15.7e", d);
    return strcmp(s, buffer);
}

You might then wrap it like so:

union tagged foo_wrapper(struct arg_list args) {
    // ... validate argument count and types ...

    return (union tagged) { .as_int = {
        .tag = TAG_INT, .data = foo(args[0].as_char_ptr.data, args[1].as_double.data)
    } };
}

and call the wrapper like so:

void demo_foo_wrapper() {
    union tagged arg_unions[2] = {
        { .as_char_ptr = { .tag = TAG_CHAR_PTR, .data = "0.0000000e+00" },
        { .as_double =   { .tag = TAG_DOUBLE,   .data = 0.0 }
    };
    union tagged result = foo_wrapper((struct arg_list) { .num = 2, .args = arg_unions});
    printf("result: %d\n", result.as_int.data);
}

---

Update:

I suggested tagged unions because the tags correspond to the field directives in the format strings described in the question, but if they aren't useful to you in practice then they are not an essential detail of this approach. If the called functions will work on the assumption that the caller has packed arguments correctly, and you have no other use for tagging the data with their types, then you can substitute a simpler, plain union for a tagged union:

union varying {
    int as_int;
    double as_double;
    char *as_char_ptr;
    // etc.
};

struct arg_list {
    unsigned num;
    union varying *args;
};

union varying foo_wrapper(struct arg_list args) {
    return (union vaying) { .as_int = foo(args[0].as_char_ptr, args[1].as_double) };
}

void demo_foo_wrapper() {
    union varying arg_unions[2] = {
        .as_char_ptr = "0.0000000e+00",
        .as_double   = 0.0
    };
    union varying result = foo_wrapper((struct arg_list) { .num = 2, .args = arg_unions});
    printf("result: %d\n", result.as_int);
}