Concatenate strings in #define without strcat - c

Question

In the project that I'm working on I have a code similar to this one:
#include<stdio.h>
struct parameter_struct{
char *parameter_name;
int parameter_value;
};
int main(){
struct parameter_struct param1= {"x_custom_param1", 6};
printf("parameter name: %s\n", param1.parameter_name);
return 0;
}
what I need to achieve now is to make the parameter name dynamic using predefined macro:
#define macro_custom "x_custom1_"
so the parameter name should be the macro value concatenated with "param1" substring. I mean it will be "x_custom1_param1" instead of the actual static value "x_custom_param1".
In my project all parameters are statically declared like that:
{"x_custom_param1", 6};
and I mustn't touch this structure of code. So I can't initialize those parameters dynamically in c function for example and use strcat in this function.
So what I thought about is to use an other #define with ## statement. So my code will be like that:
#include<stdio.h>
#define macro_custom "x_custom1_"
#define f(g,h) g##h
struct parameter_struct{
char *parameter_name;
int parameter_value;
};
int main(){
struct parameter_struct param1= {f(macro_custom, "param1"), 6};
printf("parameter name : %s\n", param1.parameter_name);
return 0;
}
but I get a compilation error:
error: pasting "macro_custom" and ""param1"" does not give a valid preprocessing token
struct parameter_struct param1= {f(macro_custom, "param1"), 6};
and that seems logical because the macro that I defined doesn't return a string with ##
Has someone an idea how I can correct my idea? or is there a better idea?

Answer 1

The feature you are looking for is string pasting. Adjacent string constants will be combined by the compiler -- you don't need an operator.
#define f(g, h) (g h)
Keep in mind that this trick only works for string constants. It won't work on variables.

Answer 2

it's simpler then what I thought. I found it in an old project.
#include<stdio.h>
#define macro_custom "x_custom1_"
struct parameter_struct{
char *parameter_name;
int parameter_value;
};
int main(){
struct parameter_struct param1= {macro_custom"param1", 6};
printf("parameter name : %s\n", param1.parameter_name);
return 0;
}

Answer 3

String literals can be concatenated this way "str1""str2"
macro function can concatenate two string literals - #define STRCAT(str1, str2) str1##str2
And when it comes to variables, you use strcat()
More efficient approach is to use string managing utilities such as GString.
It keeps track of the end of string and it handles memory expansions for you.
Keeping track of the end of string is always cost-free operation, as you always reach the end when copying it anyway.
Another approach is to use strchr() to find \0 and then copy string with conventional methods at this offset plus one byte forwards.
Also, I think OP's question would be much clearer if it states that string concatenation at compile / pre-processor (the comment belows throws some light on the exact phase it happens in) time is needed.
Those concepts uncover entire different universes.

Answer 4

Try the ‘#’ preprocessing operator which convert a macro argument into a string constant.
#define NEW_PARA_STRUCT(paramx, value) struct parameter_struct paramx={(macro_custom #paramx), value}
Example:
#include <stdio.h>
#define macro_custom "x_custom1_"
#define f(g,h) (g h)
#define NEW_PARA_STRUCT(paramx, value) struct parameter_struct paramx={(macro_custom #paramx), value}
struct parameter_struct{
char *parameter_name;
int parameter_value;
};
int main(){
struct parameter_struct param1= {f(macro_custom, "param1"), 6};
NEW_PARA_STRUCT(param2, 7);
printf("parameter name : %s\n", param1.parameter_name);
printf("parameter name : %s\n", param2.parameter_name);
return 0;
}