How to programmatically map integers to const strings? - c

Question

I have a bunch of error codes (0,1,10,11,20,30,40,...) that I need to map to their corresponding error messages. Since the error codes cannot conveniently be used as indeces into an array (it would be sparse and wasteful), I am thinking that this could somehow be accomplished with macros and/or enums.
I am basically trying to create a function const char *my_strerror(int errorcode).
const char *err00 = "an error message";
const char *err01 = "a different one";
const char *err10 = "another one";
const char* chatter_strerror(int error){
switch(error){
case 0:
return err00;
case 1:
return err01;
case 10:
return err10;
.... // 10 more cases
}
}
Surely there is a more elegant way to do this?

Answer 1

One solution would be to create an error message structure that contains an int field for the error code, and a char * field for the error message. Then an array of error message structs can be initialized with error codes and messages. This approach makes it easy to update the code with new error messages, and if the final struct in the array of error messages is used as a sentinel with a null pointer in the .msg field, functions which iterate over the array will not need to know how many elements it contains.
Here is an example. The get_error() function loops over the array, breaking out of the loop when the desired error code is encountered. If the sentinel value is reached and no match has been found, an "Unrecognized error code" message is returned. Note that there is no need to modify the get_error() function as new error messages are added to the error_codes[] array.
#include <stdio.h>
struct Errors
{
const char *msg;
int code;
};
struct Errors error_codes[] = {
{ .code = 1, .msg = "input error" },
{ .code = 5, .msg = "format error" },
{ .code = 10, .msg = "allocation error" },
{ .msg = NULL }
};
const char * get_error(int err_code);
int main(void)
{
printf("Error: %s\n", get_error(1));
printf("Error: %s\n", get_error(5));
printf("Error: %s\n", get_error(10));
printf("Error: %s\n", get_error(-1));
return 0;
}
const char * get_error(int err_code)
{
struct Errors *current = error_codes;
const char *ret_msg = "Unrecognized error code";
while (current->msg) {
if (current->code == err_code) {
ret_msg = current->msg;
break;
}
++current;
}
return ret_msg;
}
OP has specified int error codes, but also mentioned enums. Here is a modification using an enum. One advantage of using an enum here is increased readablility. A disadvantage is that now code must be modified in two places when error messages change.
#include <stdio.h>
/* Modify both the Error_Codes enum and the following error_codes[] array
when adding new error messages. */
enum Error_Codes {
ERRINPUT = 1,
ERRFORMAT = 5,
ERRALLOC = 10
};
struct Errors
{
const char *msg;
enum Error_Codes code;
};
struct Errors error_codes[] = {
{ .code = ERRINPUT, .msg = "input error" },
{ .code = ERRFORMAT, .msg = "format error" },
{ .code = ERRALLOC, .msg = "allocation error" },
{ .msg = NULL }
};
const char * get_error(enum Error_Codes err_code);
int main(void)
{
printf("Error: %s\n", get_error(ERRINPUT));
printf("Error: %s\n", get_error(ERRFORMAT));
printf("Error: %s\n", get_error(ERRALLOC));
printf("Error: %s\n", get_error(-1));
return 0;
}
const char * get_error(enum Error_Codes err_code)
{
struct Errors *current = error_codes;
const char *ret_msg = "Unrecognized error code";
while (current->msg) {
if (current->code == err_code) {
ret_msg = current->msg;
break;
}
++current;
}
return ret_msg;
}
Program output:
Error: input error
Error: format error
Error: allocation error
Error: Unrecognized error code