replacement for macro with # and ##

[jjleto]

I have a C program that uses in some parts macros with # and ## like in:

#define GET_FUNC_DECL(name) char *get##name();

#define GET_FUNC_IMPL(name) char *get##name() { /* some stuff */; return
#name; }


Is there a way to achieve this without macros in C++ ? With templates
perhaps ?

Thanks.

 

[Victor Bazarov]

I have a C program that uses in some parts macros with # and ## like in:

#define GET_FUNC_DECL(name) char *get##name();

#define GET_FUNC_IMPL(name) char *get##name() { /* some stuff */; return
#name; }


Is there a way to achieve this without macros in C++ ? With templates
perhaps ?

It depends on what you mean by "this". Preprocessor macros are a way to
substitute one string in the source code with another while performing
some operations like converting to literals or merging tokens. It is all
done before the compiler gets to it. Templates are a way to make compiler
generate code when needed based on arguments provided.

What exactly are you trying to accomplish?

V

 

[jjleto]

Victor Bazarov a écrit :

It depends on what you mean by "this". Preprocessor macros are a way to
substitute one string in the source code with another while performing
some operations like converting to literals or merging tokens. It is all
done before the compiler gets to it. Templates are a way to make compiler
generate code when needed based on arguments provided.

I understand that. But after preprocessing and compiling, we end with
code generated for the macros/templates (although completely
differentely I guess)

What exactly are you trying to accomplish?

V

I just try to get rid of the macros.
I was thinking of something like

template<char *name>
char *get()
{
/* ... */
return name;
}

and a call like

get< "foo" >();

But this does not compile.


Thanks.

 

[Victor Bazarov]

Victor Bazarov a écrit :



I understand that. But after preprocessing and compiling, we end with
code generated for the macros/templates (although completely
differentely I guess)



I just try to get rid of the macros.
Why?

I was thinking of something like

template<char *name>
char *get()
{
/* ... */
return name;
}

and a call like

get< "foo" >();

But this does not compile.

And it won't. String literals have internal linkage, therefore they
cannot be used as template arguments. But that's not the actual issue
here, is it?

Again, what are you trying to accomplish? Why not, for example, have
the _function_ argument instead of the template argument:

char* get(const char* whattoget) {
if (isname(whattoget))
return name;
else if (issomethingelse(whattoget))
return somethingelse;
else
return NULL;
}

Yes, that's run-time behaviour, not compile-time.

"Getting rid of macros" should not be the goal to pursue. Macros are just
as part of the C++ language as templates, and they are not on their way
out, and won't be any time soon. If they help you organize the code and
make it easier to write and understand, why get rid of them?

Victor

 

[maninalift]

I have a C program that uses in some parts macros with # and ## like in:

#define GET_FUNC_DECL(name) char *get##name();

#define GET_FUNC_IMPL(name) char *get##name() { /* some stuff */; return
#name; }


Is there a way to achieve this without macros in C++ ? With templates

perhaps ?

Thanks.

using macros and ## is the ONLY way to generate identifiers (i.e.
function and type names). Presumabaly the GET_FUNC_DECL macro also
takes some other parameters.

You can use templates but the "name" would have to be an identifier of
it's own (after all, that is closer to what "name" is in the macro).
For instance you could write:

template </*...parameters which define what the function does..*/>
class a_base_class{
rtn_type static get();
rtn_type static do_somthing_else();
};

template</*..same stuff again*/>
a_base_class<parameter>::get(){/*default implementation*/}

//spaecialuizations


then to give a specific name to the function just define

class nameublic a_base_class<..parameters..>{};

//which can then be used like:

int main(){
name::get();
name::do_somthing_else();
}


PERHAPS BETTER TO USE TYPEDEF RATHER THAN INHERITANCE (THOUGH
INHERITENCE ALLOWS YOU TO BE MORE EXPLICIT IN SPECIALIZATIONS:
typedef a_base_class<with these parameters> name;