how can i short name a compile time state ?

Discussion in 'C++' started by toton, Feb 25, 2008.

  1. toton

    toton Guest

    Hi,
    I want to remember a compile time variable state, just to have some
    typing convenience. I am not sure if I can do it using some typedef.
    To give a short example,
    I have an enum as,

    enum dir_type{
    dir_x,dir_y,dir_xd
    };

    and 2 specializations as,

    template<dir_type>
    dir_type o_dir();

    template<>
    dir_type o_dir<dir_x>(){
    return dir_y;
    }
    template<>
    dir_type o_dir<dir_y>(){
    return dir_x;
    }

    now in a function I want to do,

    template<dir_type dt>
    void funct(){
    std::cout<<dt<<std::endl;
    dir_type od = o_dir<dt>(); /// what would be compile time equiv of
    this line so than i can call next line?
    dir_type d = o_dir<od>();
    }
    Now for the commented line, I want a compile time typedef , so that od
    is a name rather than a runtime state, and I can call the next line.
    This is just to remove repetitive writing of o_dir<dt> , in several
    places when i can simply write od.

    thanks
    abir
     
    toton, Feb 25, 2008
    #1
    1. Advertising

  2. toton a écrit :
    > Hi,
    > I want to remember a compile time variable state, just to have some
    > typing convenience. I am not sure if I can do it using some typedef.
    > To give a short example,
    > I have an enum as,
    >
    > enum dir_type{
    > dir_x,dir_y,dir_xd
    > };
    >
    > and 2 specializations as,
    >
    > template<dir_type>
    > dir_type o_dir();
    >
    > template<>
    > dir_type o_dir<dir_x>(){
    > return dir_y;
    > }
    > template<>
    > dir_type o_dir<dir_y>(){
    > return dir_x;
    > }
    >
    > now in a function I want to do,
    >
    > template<dir_type dt>
    > void funct(){
    > std::cout<<dt<<std::endl;
    > dir_type od = o_dir<dt>(); /// what would be compile time equiv of
    > this line so than i can call next line?
    > dir_type d = o_dir<od>();
    > }
    > Now for the commented line, I want a compile time typedef , so that od
    > is a name rather than a runtime state, and I can call the next line.
    > This is just to remove repetitive writing of o_dir<dt> , in several
    > places when i can simply write od.


    You cannot use a runtime variable (od) to specialize your template
    (o_dir). If your program really has the form you gave (i.e. it returns
    fixed values), you can transform your functions into mapping structures:

    template<dir_type>
    struct o_dir();

    template<>
    struct o_dir<dir_x>
    {
    static const dir_type value = dir_y;
    }

    template<>
    struct o_dir<dir_y>
    {
    static const dir_type value = dir_x;
    }

    template<dir_type dt>
    void funct()
    {
    std::cout<<dt<<std::endl;
    static const dir_type od = o_dir<dt>::value;
    /* static const */dir_type d = o_dir<od>::value;
    }

    Michael
     
    Michael DOUBEZ, Feb 25, 2008
    #2
    1. Advertising

  3. toton

    James Kanze Guest

    On Feb 25, 8:36 am, toton <> wrote:

    > I want to remember a compile time variable state, just to have some
    > typing convenience. I am not sure if I can do it using some typedef.
    > To give a short example,
    > I have an enum as,


    > enum dir_type{
    > dir_x,dir_y,dir_xd
    > };


    > and 2 specializations as,


    > template<dir_type>
    > dir_type o_dir();


    > template<>
    > dir_type o_dir<dir_x>(){
    > return dir_y;}


    > template<>
    > dir_type o_dir<dir_y>(){
    > return dir_x;
    > }


    > now in a function I want to do,


    > template<dir_type dt>
    > void funct(){
    > std::cout<<dt<<std::endl;
    > dir_type od = o_dir<dt>(); /// what would be compile time equiv of
    > this line so than i can call next line?
    > dir_type d = o_dir<od>();}


    > Now for the commented line, I want a compile time typedef , so
    > that od is a name rather than a runtime state, and I can call
    > the next line. This is just to remove repetitive writing of
    > o_dir<dt> , in several places when i can simply write od.


    As you've written it, you can't. od is a value, initialized by
    the return value of a function, and as such, is not a compile
    time constant (at least not yet---there's some discussion of
    allowing such trivial functions to be used in constant
    expressions).

    I'm not too sure what you're trying to achieve. Perhaps
    something like:

    template< dir_type >
    struct o_dir ;
    template<>
    struct o_dir< dir_x >
    {
    static dir_type const other = dir_y ;
    } ;
    // etc.

    could be used, e.g.:

    template< dir_type dt >
    void
    funct()
    {
    dir_type const od = o_dir::eek:ther ;
    dir_type d = o_dir< od >::eek:ther ;
    // ...
    }

    --
    James Kanze (GABI Software) email:
    Conseils en informatique orientée objet/
    Beratung in objektorientierter Datenverarbeitung
    9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
     
    James Kanze, Feb 25, 2008
    #3
  4. toton

    toton Guest

    On Feb 25, 1:56 pm, James Kanze <> wrote:
    > On Feb 25, 8:36 am, toton <> wrote:
    >
    >
    >
    > > I want to remember a compile time variable state, just to have some
    > > typing convenience. I am not sure if I can do it using some typedef.
    > > To give a short example,
    > > I have an enum as,
    > > enum dir_type{
    > > dir_x,dir_y,dir_xd
    > > };
    > > and 2 specializations as,
    > > template<dir_type>
    > > dir_type o_dir();
    > > template<>
    > > dir_type o_dir<dir_x>(){
    > > return dir_y;}
    > > template<>
    > > dir_type o_dir<dir_y>(){
    > > return dir_x;
    > > }
    > > now in a function I want to do,
    > > template<dir_type dt>
    > > void funct(){
    > > std::cout<<dt<<std::endl;
    > > dir_type od = o_dir<dt>(); /// what would be compile time equiv of
    > > this line so than i can call next line?
    > > dir_type d = o_dir<od>();}
    > > Now for the commented line, I want a compile time typedef , so
    > > that od is a name rather than a runtime state, and I can call
    > > the next line. This is just to remove repetitive writing of
    > > o_dir<dt> , in several places when i can simply write od.

    >
    > As you've written it, you can't. od is a value, initialized by
    > the return value of a function, and as such, is not a compile
    > time constant (at least not yet---there's some discussion of
    > allowing such trivial functions to be used in constant
    > expressions).
    >
    > I'm not too sure what you're trying to achieve. Perhaps
    > something like:
    >
    > template< dir_type >
    > struct o_dir ;
    > template<>
    > struct o_dir< dir_x >
    > {
    > static dir_type const other = dir_y ;
    > } ;
    > // etc.
    >
    > could be used, e.g.:
    >
    > template< dir_type dt >
    > void
    > funct()
    > {
    > dir_type const od = o_dir::eek:ther ;
    > dir_type d = o_dir< od >::eek:ther ;
    > // ...
    > }
    >
    > --
    > James Kanze (GABI Software) email:
    > Conseils en informatique orientée objet/
    > Beratung in objektorientierter Datenverarbeitung
    > 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34


    Hi thanks for the solution. It is working, and this is what I wanted.
    However one problem is that , its name causes problem with one of
    runtime function defined as,
    dir_type o_dir(dir_type dir);
    Can I put same name struct and function definition in same name space,
    or I need to rename 2 versions as different name.
    (What i wanted to achieve with this is, one version which returns
    orthogonal direction in run time using switch case statement, another
    compile time version like const std::size_t dir_x =0; const
    std::size_t dir_y = 1;
    std::size_t o_dir[] = {dir_y,dir_x}; kind of lookup, except, I wanted
    it in terms of enum, where values are not sequential (but finite) ,
    and safe. In this version I cant make dir_y = 1000; If I make, 1000
    size array is required.
    another option is to use some kind of static (compile time ) map. But
    I found the solution proposed by you a simpler one)

    Thanks for responds
    abir
     
    toton, Feb 27, 2008
    #4
  5. toton

    James Kanze Guest

    On Feb 27, 7:12 am, toton <> wrote:
    > On Feb 25, 1:56 pm, James Kanze <> wrote:


    [...]
    > > I'm not too sure what you're trying to achieve. Perhaps
    > > something like:


    > > template< dir_type >
    > > struct o_dir ;
    > > template<>
    > > struct o_dir< dir_x >
    > > {
    > > static dir_type const other = dir_y ;
    > > } ;
    > > // etc.


    > > could be used, e.g.:


    > > template< dir_type dt >
    > > void
    > > funct()
    > > {
    > > dir_type const od = o_dir::eek:ther ;
    > > dir_type d = o_dir< od >::eek:ther ;
    > > // ...
    > > }

    >
    > Hi thanks for the solution. It is working, and this is what I wanted.
    > However one problem is that , its name causes problem with one of
    > runtime function defined as,
    > dir_type o_dir(dir_type dir);
    > Can I put same name struct and function definition in same
    > name space, or I need to rename 2 versions as different name.


    You can use the same name for both a class and a function in the
    same scope, but I wouldn't. It's a hack, present only for
    reasons of C compatibility, and will confuse the readers. I'd
    come up with some different names. (Generally, the name of a
    function should be a verb; the name of a class never is.)

    > (What i wanted to achieve with this is, one version which returns
    > orthogonal direction in run time using switch case statement, another
    > compile time version like const std::size_t dir_x =0; const
    > std::size_t dir_y = 1;
    > std::size_t o_dir[] = {dir_y,dir_x}; kind of lookup, except, I wanted
    > it in terms of enum, where values are not sequential (but finite) ,
    > and safe. In this version I cant make dir_y = 1000; If I make, 1000
    > size array is required.


    I'm not sure I understand completely, but perhaps some sort of
    metaprogramming trick could be used.

    --
    James Kanze (GABI Software) email:
    Conseils en informatique orientée objet/
    Beratung in objektorientierter Datenverarbeitung
    9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
     
    James Kanze, Feb 27, 2008
    #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. David Geering

    longs, long longs, short short long ints . . . huh?!

    David Geering, Jan 8, 2007, in forum: C Programming
    Replies:
    15
    Views:
    565
    Keith Thompson
    Jan 11, 2007
  2. Replies:
    4
    Views:
    831
    Kaz Kylheku
    Oct 17, 2006
  3. Ioannis Vranos

    unsigned short, short literals

    Ioannis Vranos, Mar 4, 2008, in forum: C Programming
    Replies:
    5
    Views:
    684
    Eric Sosman
    Mar 5, 2008
  4. Carter
    Replies:
    2
    Views:
    510
    Carter
    Mar 4, 2009
  5. Andre
    Replies:
    5
    Views:
    542
    Keith Thompson
    Jul 17, 2012
Loading...

Share This Page