From -6448654160058943641
X-Google-Language: ENGLISH,ASCII-7-bit
X-Google-Thread: f78e5,ede379f5dbbc1549
X-Google-Attributes: gidf78e5,public
From: Kevin Kostrzewa <tkkost@newsguy.com>
Subject: Re: Suggestion: "typeof" keyword
Date: 1999/08/24
Message-ID: <wk4shp3qij.fsf@newsguy.com>#1/1
X-Deja-AN: 516771656
X-NNTP-Posting-Host: n31.creativesol.com
Approved: stephen.clamage@sun.com (comp.std.c++)
References: <7nt3vl$1oe$1@nnrp1.deja.com> <7oh7o8$t3f$1@nnrp1.deja.com> <7ol6hi$ej9$2@news.BelWue.DE> <cTiioXAhAwr3Ew$X@robinton.demon.co.uk> <t7d7ww1vrz.fsf@calumny.jyacc.com> <e4DSyfA4ALs3Ew0Q@robinton.demon.co.uk> <t7r9laz5hj.fsf@calumny.jyacc.com> <7oup0a$8g2$1@nnrp1.deja.com> <37B3C2AD.5AB722AE@lucent.com> <37B5A571.449B@wanadoo.fr> <37B908A8.717CAC2C@lucent.com> <CVJFZFAbaWu3Ew15@robinton.demon.co.uk> <7pcvjs$tk4$1@nnrp1.deja.com> <user-1808991258230001@aus-as3-121.io.com> <37BBE6CC.FE2475E5@physik.tu-muenchen.de> <user-1908991352370001@aus-as5-169.io.com> <slrn7rph2r.e43.sbnaran@localhost.localdomain>
X-UID: 0000000001
X-Status: $$$T
Organization: Msen, Inc.
Newsgroups: comp.std.c++
Originator: clamage@taumet


sbnaran@uiuc.edu (Siemel B. Naran) writes:
> I think that allowing "::" to be applied to the return types of
> functions but not introducing the 'typeof' keyword would be a
> better idea than introducing the 'typeof' keyword but leaving
> the "::" rules alone.  Then we could implement struct typeof in
> terms of the existing core language.  This saves us the ordeal
> of figuring out the semantics of 'typeof'.

I totally agree, but I'd like :: to be able to be applied to any
expression, not just a function return type.  If, as Siemel suggested,
:: could be applied to the return type of a function, typeof could be
written in terms of the language, but it would have to have a slightly
different syntax if you wanted the typeof an expression vs. the typeof
a type:

template<class T> struct Typeof_tp { typedef T type; };
template<class T> Typeof_tp<T> typeof(T) { return Typeof_tp<T>(); }
template<class T> Typeof_tp<T> typeof() { return Typeof_tp<T>(); }

   class Foo;
   typeof<Foo>()::type t;
   Foo f;
   typeof(f)::type t;

Also, if typeof is written in terms of the language, can we be
guaranteed that the expression passed down to the typeof() function
that accepts one parameter is not evaluated (like we are guaranteed
for sizeof() when it is passed an expression?)  That might hinder

   typeof(*(int *)0 + *(double *)0)::type t;

Finally, I think that the people who want declare, as well as typeof
can be appeased as well, as something like declare could be written
using the language:

   // warning - this code will not compile!  plus, it's pretty damn
   // ugly.
template<class T>
class Declare_tp
{
public:
  struct initialized_type
  {
    initialized_type() : 
      m_t(*Declare_tp<T>::s_ptcur)
      {}

    operator T &() { return m_t; }
    operator const T &() const { return m_t; }
    T *operator&() { return &m_t; }
    const T *operator&() const { return &m_t; }
    T &operator=(const T &other) 
      {
	m_t = other;
	return *this;
      }

  private:
    T m_t;
  };

  static const T *s_ptcur;
  Declare_tp(const T &tcur) 
    {
      s_ptcur = &tcur;
    }

  typedef T type;
};

template<class T> 
const T *Declare_tp<T>::s_ptcur;


// usage:
int x = 1;
double y = 2.5;


declare(x+2y)::initialized_type t;
declare(x+2y)::type t2;
   // t should be 6.0 and convertable to double
   // t2 should be of type double, uninitialized

-- 
kevin kostrzewa
work: kkostrzewa@csisolutions.com
home: tkkost@newsguy.com


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]