replacement for macro with # and ##

Discussion in 'C++' started by jjleto, Dec 1, 2004.

  1. jjleto

    jjleto Guest

    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.
    jjleto, Dec 1, 2004
    #1
    1. Advertising

  2. jjleto wrote:
    > 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
    Victor Bazarov, Dec 1, 2004
    #2
    1. Advertising

  3. jjleto

    jjleto Guest

    Victor Bazarov a écrit :
    > jjleto wrote:
    >
    >> 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.


    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.
    jjleto, Dec 1, 2004
    #3
  4. jjleto wrote:
    > Victor Bazarov a écrit :
    >
    >> jjleto wrote:
    >>
    >>> 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.

    >
    >
    > 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.


    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
    Victor Bazarov, Dec 1, 2004
    #4
  5. jjleto

    Guest

    jjleto wrote:
    > 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 name:public 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;
    , Dec 3, 2004
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Dead RAM
    Replies:
    20
    Views:
    1,111
    John Harrison
    Jul 14, 2004
  2. D Senthil Kumar

    macro name from macro?

    D Senthil Kumar, Sep 20, 2003, in forum: C Programming
    Replies:
    1
    Views:
    580
    Jack Klein
    Sep 21, 2003
  3. Replies:
    3
    Views:
    310
  4. Pavel
    Replies:
    2
    Views:
    459
    Pavel
    Jun 23, 2012
  5. Shriramana Sharma

    Order of preprocessor macro replacement

    Shriramana Sharma, Jun 15, 2013, in forum: C Programming
    Replies:
    3
    Views:
    182
    Walter Banks
    Jun 17, 2013
Loading...

Share This Page