May 2000 Frame page

<body stylesrc="index.html" background="images/Bkgrnd02T2.gif"> <table border="0" cellpadding="6" cellspacing="0" height="518"> <tr> <td align="right" valign="top" height="1"> <p align="center"><img border="0" src="images/Accent03.gif" align="left" width="142" height="37"> </p> <p align="left"><b><font size="2">May 2000 - Vol. 1 No. 5</font></b></p> </td> <td valign="bottom" height="1"> <p align="center">  <a href="index.html" target="_top">[Home]</a> <a href="Newsletters.html" target="_top">[Up]</a> <a href="2000-06.html" target="_top">[Next]</a> <a href="2000-04.html" target="_top">[Previous]</a></td> </tr> <tr> <td valign="top" height="529" bgcolor="#FFFFCC"> <p><font size="2"> <a href="#TechTalk"><b>Tech Talk</b></a></font><font size="3"><br> </font><a href="#PortableTypeof"><font size="2">A Portable typeof Operator</font><br> </a><font size="2"> <b><br> </b><a href="#Editorial"><b>Editorial</b></a></font> <font size="3"><br> </font><font size="2"><a href="#Bigger">Bigger and Better</a><a href="#NotRosy"><br> Not All Rosy</a></font><a href="#ElectronicNewsletter"><br> Electronic Newsletter<font size="2"><br> </font> </a><font size="2"> <br> <a href="#Trends"><b>Trends</b></a> </font> <font size="4"><br> </font><font size="2"><a href="#Languages">Languages</a><a href="#Platforms"><br> Platforms</a><a href="#HowWeCalculate"><br> How We Calculate</a></font> </p> </td> <td valign="top" height="277" bgcolor="#FFCC99"> <h1> <b><font color="#000000"><a name="TechTalk">Tech Talk</a></font></b></h1> <h2> <b><font FACE="Arial"><a name="PortableTypeof">A Portable <i>typeof </i>Operator</a></font></b></h2> <i> <p>By Bill Gibbons, Pixo, Inc.<br> Copyright 2000 © Bill Gibbons<br> All rights reserved.</p> </i><b> <h3><font FACE="Arial" color="#000000" size="4"> The Problem </font></h3> </b> <p>Sometimes it is useful to declare a variable with a type that is not known directly, but is known to be “the type of this expression”. For example:</p> <table border="1"> <tr> <td width="100%"><font size="2"><font FACE="Courier New"><font color="#008000">void</font> </font><font face="Courier New" color="#008000">f(LibClass *p)<br> {<br>    typeof(p->val) value=p->val;<br>      /* ... */<br> }</font></font></td> </tr> </table> <p>where “<font face="Courier New" size="2" color="#008000">typeof(p->val)</font>” yields a type that is used to declare the local “<font face="Courier New" size="2" color="#008000">val</font>”. This is particularly useful in templates, where many of the types in use are not known ahead of time.</p> <p>Some compilers implement a <font face="Courier New" size="2">typeof</font> keyword as an extension, but code that uses such an extension is not portable. This article describes a portable way to write a <font face="Courier New" size="2">typeof</font> operator.</p> <b> <h3><font FACE="Arial" color="#000000" size="4"> Almost Enough </font></h3> </b> <p>C++ has almost enough functionality to do <font face="Courier New" size="2" color="#008000">typeof</font>. Function templates can be used to extract a type from an expression and declare a <font face="Courier New" size="2" color="#008000"> typedef</font> of that type:</p> <table border="1"> <tr> <td width="100%"><font size="2" color="#008000" face="Courier New">template<class T> void f(T) { typedef T TheType; }<br> void g() { f(123); } // TheType is “int”</font></td> </tr> </table> <p>Here the typedef “<font face="Courier New" size="2" color="#008000">TheType</font>” in the instantiated function template “<font face="Courier New" size="2" color="#008000">f<int></font>” has the same type as the expression “<font face="Courier New" size="2" color="#008000">123</font>”. But, there is no way to export the type from the function, so by itself this is not useful for implementing <font face="Courier New" size="2" color="#008000">typeof</font>.</p> <p>Similarly, overloading can be used to select a function that contains a <font face="Courier New" size="2" color="#008000"> typedef</font> that matches the type:</p> <table border="1"> <tr> <td width="100%"><font size="2" color="#008000" face="Courier New">void f(char) { typedef int TheType; }<br> void f(short) ( typedef short TheType; }<br> void g() { f('x'); } // TheType is "char"</font></td> </tr> </table> <p>but there is no way to extract the type.</p> <p>Class templates can be used to map a value or type to another value or type:</p> <table border="1"> <tr> <td width="100%"><font size="2" color="#008000" face="Courier New">template<class T> struct U; // no definition needed<br> template<> struct U<char> { typedef unsigned char type; };<br> template<> struct U<short>{ typedef unsigned short type; };<br> void f()<br> {<br>     U<char>::type a;  //unsigned char<br>     U<short>::type b; //unsigned short<br> }</font></td> </tr> </table> <p>But you cannot use a class template to extract a type from an expression, as you can with function templates or overloading. (If the expression is a name with external linkage it is possible to implement <font face="Courier New" size="2">typeof</font> with class templates, but this is not very useful.)</p> <p>Function templates and overloaded functions can also map an expression of one type into an expression of another type, as in:</p> <table border="1"> <tr> <td width="100%"><font size="2" color="#008000" face="Courier New">unsigned char U(char x) { return x; }<br> unsigned short U(short x) { return x; }</font> <p><font size="2" color="#008000" face="Courier New">void f()<br> {<br>    short s = 0;<br>        s;    // expression "s" has type "short"<br>        U(s); // expression "U(s)" has type "unsigned short"</font></p> <p><font face="Courier New" size="2" color="#008000">}</font></td> </tr> </table> <p>This is also not sufficient, although it turns out to be part of the solution.</p> <p>We need some way to map the type of an expression to something that can be used as a template argument. The only construct in the language that can do this is <font face="Courier New" size="2" color="#008000">sizeof</font>. It happens that <font face="Courier New" size="2" color="#008000">sizeof</font> is sufficient.</p> <b><font FACE="Arial"> <h3><font size="4" color="#000000" face="Arial">The Solution</font></h3> </font></b> <p>The trick is to map each type to a unique integer value using overloaded functions and <font face="Courier New" size="2">sizeof</font>. Then template specializations can map the integer value to the right type:</p> <ul> <li>The expression is passed to an overloaded function.</li> <li>The return type of the particular function selected is <font FACE="Times New Roman" SIZE="2">“</font>pointer to array of char<font FACE="Times New Roman" SIZE="2">”</font>, with the array size being unique to the type.</li> <li>The <font face="Courier New" color="#008000" size="2">sizeof</font> operator extracts the array size as a constant. The function is never actually called and so does not need a definition.</li> <li>The constant is used to select a class template among a set of specializations; the selected class template contains a typedef with the right type.</li> </ul> <b><font FACE="Arial"> <h3><font size="4" color="#000000">Simple Example</font></h3> </font></b> <p>The following example shows a simple <font face="Courier New" size="2">typeof</font> that handles expressions of type <font face="Courier New" size="2">short</font>, <font face="Courier New" size="2">int</font> and <font face="Courier New"><font size="2">long</font>.</font></p> <table border="1"> <tr> <td width="100%"><font face="Courier New" size="2" color="#008000">template<int N> struct typeof_c;// No def'n, only specializations<br> template<> struct typeof_c<1> { typedef short V; };<br> template<> struct typeof_c<2> { typedef int V; };<br> template<> struct typeof_c<3> { typedef long V; };</font> <p><font face="Courier New" size="2" color="#008000">typedef char CharArrayOf1[1];<br> typedef char CharArrayOf2[2];<br> typedef char CharArrayOf3[3];</font></p> <p><font face="Courier New" size="2" color="#008000">typedef CharArrayOf1 *PtrCharArrayOf1;<br> typedef CharArrayOf2 *PtrCharArrayOf2;<br> typedef CharArrayOf3 *PtrCharArrayOf3;</font></p> <p><font face="Courier New" size="2" color="#008000">PtrCharArrayOf1 typeof_f(short); // No definitions needed<br> PtrCharArrayOf2 typeof_f(int);<br> PtrCharArrayOf3 typeof_f(long);</font></p> <p><font face="Courier New" size="2" color="#008000">#define typeof(x) typeof_c<sizeof(*typeof_f(x))>::V</font></td> </tr> </table> <p>Consider what happens to “<font face="Courier New" size="2" color="#008000">typeof(123L)</font>”<font FACE="Courier New">: </font></p> <ul> <li>The macro expands to “<font size="2" face="Courier New" color="#008000">typeof_c<sizeof(*typeof_f(123L))>::V</font>”.</li> <li>The call “<font face="Courier New" size="2" color="#008000">typeof_f(123L)</font>” selects the following declaration from the set of overloaded function declarations:</li> </ul> <p><font FACE="Courier New">      <font size="2" color="#008000" face="Courier New">PtrCharArrayOf3 typeof_f(long);</font></font></p> <ul> <li>The type of “<font face="Courier New" size="2" color="#008000">typeof_f(123L)</font>” is “<font face="Courier New" size="2" color="#008000">PtrCharArrayOf3</font>”, or pointer to array of char length 3.</li> <li>The type of “<font face="Courier New">*<font size="2" color="#008000" face="Courier New">typeof_f(123L)</font></font>” is “an array of char length 3”.</li> <li>“<font face="Courier New" size="2" color="#008000">sizeof(*typeof_f(123L))</font>” is an integral constant expression with the value 3. Since the operand of <font face="Courier New" size="2">sizeof</font> is not evaluated there is no need to have a definition for <font face="Courier New" size="2">typeof_f</font>.</li> <li>The template-id “<font face="Courier New" size="2" color="#008000">typeof_c<sizeof(*typeof_f(123L))></font>” is effectively “<font face="Courier New" size="2" color="#008000">typeof_c<3></font><font FACE="Courier New" SIZE="1">” </font>which selects the specialization: </li> </ul> <p><font FACE="Courier New">      <font size="2" color="#008000" face="Courier New">template<> struct typeof_c<3> { typedef long V; };</font></font></p> <ul> <li>The qualified-id “<font face="Courier New" size="2" color="#008000">typeof_c< sizeof(*typeof_f(123L)) >::V</font>” is the above typedef which has type <font face="Courier New" size="2" color="#008000">long</font>.</li> <li>So “<font face="Courier New" size="2" color="#008000">typeof(123L)</font>” refers to a typedef of type <font face="Courier New" size="2" color="#008000">long</font>.</li> </ul> <p>Note that all of these operations happen at compile time. The generated code will be the same as if the type were written as “<font face="Courier New" size="2" color="#008000">long</font>” instead of “<font size="2" color="#008000" face="Courier New">typeof(123L)</font>”.</p> <b><font FACE="Arial"> <h3><font size="4" color="#000000">Improvements</font></h3> </font></b> <p>The <font face="Courier New" size="2">typedefs</font> in the preceding example are not really necessary and they pollute the global namespace. We can eliminate them at the risk of confusing human readers (and maybe a few compilers):</p> <table border="1"> <tr> <td width="100%"><font face="Courier New" size="2" color="#008000">char(*typeof_f(short))[1]; // fct returns ptr to array of char len 1<br> char(*typeof_f(int ))[2]; // length 2<br> char(*typeof_f(long ))[3]; // length 3</font></td> </tr> </table> <p>If we declare the parameters as references to const instead of using simple pass by value, it becomes possible to use expressions which cannot be passed by value – for example, objects of classes with private copy constructors. So in the general case, given type <font face="Courier New" size="2" color="#008000">T</font>, we want to write the <font face="Courier New" size="2" color="#008000">typeof_f</font> declaration for <font face="Courier New" size="2" color="#008000">T</font> as:</p> <table border="1"> <tr> <td width="100%"> <font SIZE="2"> <font face="Courier New" color="#008000" size="2">char(*typeof_f(const T&))[nnn];</font> </font> </td> </tr> </table> <p>Declaring the required specializations and functions can be handled much more easily with a macro:</p> <table border="1"> <tr> <td width="100%"><font size="2" color="#008000" face="Courier New">#define REGISTER_TYPEOF(N,T) \<br>   template<> struct typeof_c<N> { typedef T V; }; \<br>   char(*typeof_f(const T&))[N];</font></td> </tr> </table> <p>However, we run into trouble with some compound types. For example, if we expand:</p> <table border="1"> <tr> <td width="100%"> <font SIZE="2"> <font face="Courier New" color="#008000" size="2">REGISTER_TYPEOF( 3, void (*)() )</font> </font> </td> </tr> </table> <p>we get:</p> <table border="1"> <tr> <td width="100%"> <font SIZE="2"> <font face="Courier New" color="#008000" size="2">template<> struct typeof_c<3> { typedef void (*)() V; };<br> char(*typeof_f(const void(*)()&))[3];</font> </font> </td> </tr> </table> <p>Both of these declarations are ill-formed because combining C++ types is not as simple as substituting a type for a type name. We can make the macro work again by introducing another class template:</p> <table border="1"> <tr> <td width="100%"><font size="2" color="#008000" face="Courier New">template<class T> struct WrapType { typedef T U; };</font></td> </tr> </table> <p>This template takes advantage of the fact that when you instantiate a template with a compound type, e.g.</p> <table border="1"> <tr> <td width="100%"><font face="Courier New" size="2" color="#008000">WrapType<void (*)()></font></td> </tr> </table> <p>you create a simple name (the template parameter, in this case, <font face="Courier New" size="2" color="#008000">T</font>) for the type. We can’t get to <font face="Courier New" size="2" color="#008000">T</font> directly from outside the template but we can get to typedef <font face="Courier New" size="2" color="#008000">U</font> that has the same type. In example:</p> <table border="1"> <tr> <td width="100%"><font face="Courier New" size="2" color="#008000">WrapType<void (*)()> :: U</font></td> </tr> </table> <p>has type “<font face="Courier New" size="2" color="#008000">void (*)()</font>”. So if we replace instances of <font face="Courier New" size="2" color="#008000">T</font> in the macro with “<font face="Courier New" size="2" color="#008000">WrapType<T>::U</font>” we have the original type but in a form that we can use to build other types.</p> <p>Our macro now looks like this:</p> <table border="1"> <tr> <td width="100%"><font size="2" color="#008000" face="Courier New">#define REGISTER_TYPEOF(N,T) \<br>     template<> struct typeof_c<N> { typedef WrapType<T>::U V; }; \<br>     char (*typeof_f(const WrapType<T>::U &))[N];</font></td> </tr> </table> <p>See the program listing at the end for a more complete example using the above macro and several test types.</p> <b><font FACE="Arial"> <h3><font size="4" color="#000000">Limitations</font></h3> </font></b> <p>This approach does require that each type that might be used in <font face="Courier New" color="#008000" size="2">typeof</font> be explicitly registered with the <font face="Courier New" color="#008000" size="2">REGISTER_TYPEOF</font> macro. This limits, or at least places additional burden, on the use of this technique in general-purpose template libraries.</p> <table border="1"> <tr> <td width="100%"><font size="2" color="#008000" face="Courier New">#define REGISTER_TYPEOF(T) \<br>    template<> struct typeof_c<__LINE__> \<br>    { typedef WrapType<T>::U V; }; \<br>    char (*typeof_f(const WrapType<T>::U &))[__LINE__];</font></td> </tr> </table> <p>The need to assign a distinct ordinal to each type could be a nuisance. If all the <font face="Courier New" size="2" color="#008000">REGISTER_TYPEOF</font> uses are in a single include file the macro could be simplified by using <font face="Courier New" size="2" color="#008000">__LINE__</font> instead of <font face="Courier New" size="2" color="#008000">N</font>:</p> <p>It does not matter that the ordinals may be large and/or discontiguous; the only restriction is that they be positive and distinct.</p> <p>If the type of the expression given to <font face="Courier New" size="2">typeof</font> has not been registered, the resulting error message may be cryptic; but it should at least refer to <font face="Courier New" size="2" color="#008000">typeof_f</font> that should give a clue to the problem.</p> <b><font FACE="Arial"> <h3><font size="4" color="#000000">Conclusion</font></h3> </font></b> <p>For applications that need a <font face="Courier New" size="2" color="#008000">typeof</font> operator this technique provides most of the power of a compiler extension while keeping the code portable. This general approach of using function overloading and <font face="Courier New" size="2" color="#008000">sizeof</font> to extract expression type information can be used in other places.</p> <p>The implementation of this technique can be somewhat obscure but the uses (such as reference to <font face="Courier New" size="2" color="#008000">typeof</font>) can be kept simple. Since all of these operations occur at compile time there is no runtime cost for using them.</p> <p>A <a href="Listings/2000-05-Listing01.html" target="_top">complete source code example</a> can be found on page 4 of the printed newsletter.</p> <b> <h1><font color="#000000"><a name="Editorial">Editorial</a></font></h1> </b><i> <p>By Reg. Charney</p> </i><b> <h2><font face="Arial" color="#000000"><a name="Bigger"> Bigger and Better</a></font></h2> </b> <p>As you have probably noticed, things have changed again!. Based on the possibility of new sponsor, we have expanded things to increase this newsletter by 50% and to add color, at least to the first and last page. We have also been able to expand the length and content of our technical offerings.</p> <p>We are also planning to include several new sections. They include a book review section, and a technical summary section. The technical summary will try to summarize technical topics on a number of the C, C++ and Java reflectors that exist on the net. Let us know what more you would like.</p> <b> <h2><font face="Arial" color="#000000"><a name="NotRosy"> Not all rosy</a></font></h2> </b> <p>As this issue is about to go to press, one of our new potential sponsors has backed out – or more accurately, failed to pay the invoice, answer emails, or respond to phone messages. It is a disappointment, as you can imagine. It is also too late to change the content or layout of this issue. However, with your assistance, we can grow stronger from the experience.</p> <p>If you know firms that are committed to open source development or in the betterment of the professional programming community and the people they hire, please let them know about the ACCU and in this newsletter. Also, please tell me and I will contact them. We need sponsors and also advertisers. The benefits package that we are offering sponsors is quite impressive.</p> <b> <h2><font face="Arial" color="#000000"><a name="ElectronicNewsletter"> Electronic Newsletter</a></font></h2> </b> <p>We can now send you future issues of this newsletter as PDF files. To subscribe, please email me at</p> <p> <font FACE="Courier New"> accent-subscribe_AT_CharneyDay.com </font> </p> <p>Past issues are also available as PDF files, including versions in A4 format for our international readers. In the body of the message say if you want the A4 format and/or past issues.</p> <b> <h1><font color="#000000"><a name="Trends">Trends</a></font></h1> </b><i> <p>By Reg. Charney</p> </i> <b> <h2><font face="Arial" color="#000000"><a name="Languages"> Languages</a></font></h2> </b> <p>Again, Java leads the pack in normalized demand. However, this month HTML, Perl and XML all are in greater demand than C/C++. In fact, the rate of demand for the languages has changed dramatically. The change in demand for XML outstrips all other languages with Perl, the glue for Internet applications, an unexpected second. Perl’s importance can be seen as a growth in tools for infrastructure implementation. Note also that one of the few increasing changes in demand is in Python, another glue language.</p> <b><i> <p align="center"><font FACE="Arial" COLOR="#000099"><img border="0" src="images/2000-05-Fig01.gif" align="center" width="332" height="219"></font> </p> </i> <p align="center"><font FACE="Arial">Figure #1</font></p> <i> <p align="center"> <font FACE="Arial" COLOR="#000099"> <img border="0" src="images/2000-05-Fig02.gif" align="center" width="338" height="220"></font> </p> </i> <p align="center"><font FACE="Arial">Figure #2</font></p> <h2> <font face="Arial" color="#000000"><a name="Platforms">Platforms</a></font></h2> </b> <p>In terms of demand, you already know most of the big players – Windows and Unix. The surprise occurs in the changing demand for platform-specific skills. The big winner here is Linux followed closely by Windows 2000. This says that there is a pent up demand for Linux skills that is outstripping all other platforms. Only Windows 2000 comes close, but that is to be expected, based on the huge installed base of Windows software already in the market and which firms need to upgrade.</p> <p align="center"><img border="0" src="images/2000-05-Fig03.gif" align="center" width="331" height="221"></p> <p align="center"><b><font face="Arial">Figure #3</font></b></p> <p align="center"> <img border="0" src="images/2000-05-Fig04.gif" align="center" width="354" height="222"></p> <p align="center"><b><font face="Arial">Figure #4</font></b></p> <p>The second clear fact is that Solaris dominates the Unix marketplace and demand for expertise in it continues to grow, but at half the speed of Windows 2000 and Linux.</p> <b> <h2><font face="Arial" color="#000000"><a name="HowWeCalculate"> How We Calculate</a></font></h2> </b> <p>The source for these charts come from Internet online job sites. Thus, these numbers represent demand for new hires, not who are currently employed doing what. However, some estimates can be made from these figures, but that is a subject of another article.</p> <p>These online sites are searched by keywords and the number of “hits” are recorded. Often, defining a skill is fuzzy. For example, the category “Windows 98” is actually the Boolean expression “Windows98 or Win98 or 98“. Thus, an ad asking for experience with “W98” would be missed. Since getting some measurements is better than nothing, we compute raw demand for a skill. I often skip this chart because it is not very interesting—just a series of numbers without much context.</p> <p>The first interesting chart is the Normalized Demand set of charts. This is the demand for a particular skill divided by the demand for all skills in that category. The second chart of interest is the change in demand for a skill since the last time we did a measurement of that skill. You can think of these charts as Skill Velocity Charts – how fast is the demand for the skill changing. The last chart is the Skill Acceleration chart that represents the change in changing demand over the last period we are measuring. It measures how fast demand is changing for each skill set within a category. </td> </tr> </table> </body>