chap06.htm

This is the second part of that lab manual to teach you how to make real-time programme and how to d

  cout << endl;
  is.sort();
  <font color=#0000ff>for</font>(<font color=#0000ff>int</font> l = 0; l &lt; is.size(); l++)
    cout &lt;&lt; is[l] &lt;&lt; ' ';
  cout &lt;&lt; endl;

  <font color=#009900>// Uses the template partial specialization:</font>
  Sorted&lt;string*&gt; ss;
  <font color=#0000ff>for</font>(<font color=#0000ff>int</font> i = 0; i &lt; asz(words); i++)
    ss.push_back(<font color=#0000ff>new</font> string(words[i]));
  <font color=#0000ff>for</font>(<font color=#0000ff>int</font> i = 0; i &lt; ss.size(); i++)
    cout &lt;&lt; *ss[i] &lt;&lt; ' ';
  cout &lt;&lt; endl;
  ss.sort();
  <font color=#0000ff>for</font>(<font color=#0000ff>int</font> i = 0; i &lt; ss.size(); i++)
    cout &lt;&lt; *ss[i] &lt;&lt; ' ';
  cout &lt;&lt; endl;
  
  <font color=#009900>// Uses the full char* specialization:</font>
  Sorted&lt;<font color=#0000ff>char</font>*&gt; scp;
  <font color=#0000ff>for</font>(<font color=#0000ff>int</font> i = 0; i &lt; asz(words2); i++)
    scp.push_back(words2[i]);
  <font color=#0000ff>for</font>(<font color=#0000ff>int</font> i = 0; i &lt; scp.size(); i++)
    cout &lt;&lt; scp[i] &lt;&lt; ' ';
  cout &lt;&lt; endl;
  scp.sort();
  <font color=#0000ff>for</font>(<font color=#0000ff>int</font> i = 0; i &lt; scp.size(); i++)
    cout &lt;&lt; scp[i] &lt;&lt; ' ';
  cout &lt;&lt; endl;
} <font color=#009900>///:~</font></PRE></FONT></BLOCKQUOTE>
<DIV ALIGN="LEFT"><P><FONT FACE="Georgia">Each of the template instantiations uses
a different version of the template. <B>Sorted&lt;int&gt;</B> uses the
&#8220;ordinary,&#8221; non-specialized template. <B>Sorted&lt;string*&gt;</B>
uses the partial specialization for pointers. Lastly, <B>Sorted&lt;char*&gt;</B>
uses the full specialization for <B>char*</B>. Note that without this full
specialization, you could be fooled into thinking that things were working
correctly because the <B>words</B> array would still sort out to &#8220;a big
dog is running&#8221; since the partial specialization would end up comparing
the first character of each array. However, <B>words2</B> would not sort out
correctly, and for the desired behavior the full specialization is
necessary.</FONT><BR></P></DIV>
<A NAME="Heading173"></A><FONT FACE = "Verdana, Tahoma, Arial, Helvetica, Sans"><H4 ALIGN="LEFT">
Pointer specialization</H4></FONT>
<A NAME="Heading174"></A><FONT FACE = "Verdana, Tahoma, Arial, Helvetica, Sans"><H4 ALIGN="LEFT">
Partial ordering of function
templates<A NAME="_Toc312374085"></A><A NAME="_Toc519041996"></A></H4></FONT>
<A NAME="Heading175"></A><FONT FACE = "Verdana, Tahoma, Arial, Helvetica, Sans"><H3 ALIGN="LEFT">
Design &amp; efficiency<BR><A NAME="Index482"></A><A NAME="Index483"></A></H3></FONT>
<DIV ALIGN="LEFT"><P><FONT FACE="Georgia">In <B>Sorted</B>, every time you call
<B>add(&#160;)</B> the element is inserted and the array is resorted. Here, the
horribly inefficient and greatly deprecated (but easy to understand and code)
bubble sort <A NAME="Index484"></A><A NAME="Index485"></A>is used. This is
perfectly appropriate, because it&#8217;s part of the <B>private</B>
implementation. During program development, your priorities are
to</FONT><BR></P></DIV>
<OL>
<LI><FONT FACE="Verdana">	</FONT><FONT FACE="Georgia">Get the class interfaces
correct.</FONT><LI><FONT FACE="Verdana">	</FONT><FONT FACE="Georgia">Create an
accurate implementation as rapidly as possible so you
can:</FONT><LI><FONT FACE="Verdana">	</FONT><FONT FACE="Georgia">Prove your
design.</FONT></OL><DIV ALIGN="LEFT"><P><FONT FACE="Georgia">Very often, you will
discover problems with the class interface only when you assemble your initial
&#8220;rough draft&#8221; of the working system. You may also discover the need
for &#8220;helper&#8221; classes like containers and iterators during system
assembly and during your first-pass implementation. Sometimes it&#8217;s very
difficult to discover these kinds of issues during analysis &#8211; your goal in
analysis should be to get a big-picture design that can be rapidly
implemented<A NAME="Index486"></A> and tested. Only after the design has been
proven should you spend the time to flesh it out completely and worry about
performance issues. If the design fails, or if performance is not a problem, the
bubble sort is good enough, and you haven&#8217;t wasted any time. (Of course,
the ideal solution is to use someone else&#8217;s sorted container; the Standard
C++ template library is the first place to
look.)</FONT><A NAME="_Toc312374086"></A><A NAME="_Toc519041997"></A><BR></P></DIV>
<A NAME="Heading176"></A><FONT FACE = "Verdana, Tahoma, Arial, Helvetica, Sans"><H3 ALIGN="LEFT">
Preventing template bloat<BR><A NAME="Index487"></A><A NAME="Index488"></A></H3></FONT>
<DIV ALIGN="LEFT"><P><FONT FACE="Georgia">Each time you instantiate a template, the
code in the template is generated anew (except for <B>inline</B> functions). If
some of the functionality of a template does not depend on type, it can be put
in a common base class to prevent needless reproduction of that code. For
example, in Chapter XX in <B>InheritStack.cpp</B> inheritance was used to
specify the types that a <B>Stack</B> could accept and produce. Here&#8217;s the
templatized version of that code:</FONT><BR></P></DIV>

<BLOCKQUOTE><FONT SIZE = "+1"><PRE><font color=#009900>//: C06:Nobloat.h</font>
<font color=#009900>// Templatized InheritStack.cpp</font>
#ifndef NOBLOAT_H
#define NOBLOAT_H
#include <font color=#004488>"..</font><font color=#004488>/C0B</font><font color=#004488>/Stack4.h"</font>

<font color=#0000ff>template</font>&lt;<font color=#0000ff>class</font> T&gt;
<font color=#0000ff>class</font> NBStack : <font color=#0000ff>public</font> Stack {
<font color=#0000ff>public</font>:
  <font color=#0000ff>void</font> push(T* str) {
    Stack::push(str);
  }
  T* peek() <font color=#0000ff>const</font> {
    <font color=#0000ff>return</font> (T*)Stack::peek();
  }
  T* pop() {
    <font color=#0000ff>return</font> (T*)Stack::pop();
  }
  ~NBStack();
};

<font color=#009900>// Defaults to heap objects &amp; ownership:</font>
<font color=#0000ff>template</font>&lt;<font color=#0000ff>class</font> T&gt;
NBStack&lt;T&gt;::~NBStack() {
  T* top = pop();
  <font color=#0000ff>while</font>(top) {
    <font color=#0000ff>delete</font> top;
    top = pop();
  }
}
#endif <font color=#009900>// NOBLOAT_H ///:~</font></PRE></FONT></BLOCKQUOTE>
<DIV ALIGN="LEFT"><P><FONT FACE="Georgia">As before, the inline functions generate
no code and are thus &#8220;free.&#8221; The functionality is provided by
creating the base-class code only once. However, the ownership problem has been
solved here by adding a destructor (which <I>is</I> type-dependent, and thus
must be created by the template). Here, it defaults to ownership. Notice that
when the base-class destructor is called, the stack will be empty so no
duplicate releases will occur.</FONT><BR></P></DIV>

<BLOCKQUOTE><FONT SIZE = "+1"><PRE><font color=#009900>//: C06:NobloatTest.cpp</font>
<font color=#009900>//{L} ../TestSuite/Test </font>
#include <font color=#004488>"Nobloat.h"</font>
#include <font color=#004488>"..</font><font color=#004488>/require.h"</font>
#include &lt;fstream&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;
<font color=#0000ff>using</font> <font color=#0000ff>namespace</font> std;

<font color=#0000ff>int</font> main() {
  ifstream in(<font color=#004488>"NobloatTest.cpp"</font>);
  assure(in, <font color=#004488>"NobloatTest.cpp"</font>);
  NBStack&lt;string&gt; textlines;
  string line;
  <font color=#009900>// Read file and store lines in the stack:</font>
  <font color=#0000ff>while</font>(getline(in, line))
    textlines.push(<font color=#0000ff>new</font> string(line));
  <font color=#009900>// Pop the lines from the stack and print them:</font>
  string* s;
  <font color=#0000ff>while</font>((s = (string*)textlines.pop()) != 0) {
    cout &lt;&lt; *s &lt;&lt; endl;
    <font color=#0000ff>delete</font> s; 
  }
} <font color=#009900>///:~<A NAME="_Toc519041998"></A></font></PRE></FONT></BLOCKQUOTE><A NAME="Heading177"></A><FONT FACE = "Verdana, Tahoma, Arial, Helvetica, Sans"><H2 ALIGN="LEFT">
Explicit instantiation<BR><A NAME="Index489"></A><A NAME="Index490"></A></H2></FONT>
<DIV ALIGN="LEFT"><P><FONT FACE="Georgia">At times it is useful to explicitly
instantiate a template; that is, to tell the compiler to lay down the code for a
specific version of that template even though you&#8217;re not creating an
object at that point. To do this, you reuse the <B>template</B> keyword as
follows:</FONT><BR></P></DIV>

<BLOCKQUOTE><FONT SIZE = "+1"><PRE><font color=#0000ff>template</font> <font color=#0000ff>class</font> Bobbin&lt;thread&gt;;
<font color=#0000ff>template</font> <font color=#0000ff>void</font> sort&lt;<font color=#0000ff>char</font>&gt;(<font color=#0000ff>char</font>*[]);</PRE></FONT></BLOCKQUOTE>
<DIV ALIGN="LEFT"><P><FONT FACE="Georgia">Here&#8217;s a version of the
<B>Sorted.cpp</B> example that explicitly instantiates a template before using
it:</FONT><BR></P></DIV>

<BLOCKQUOTE><FONT SIZE = "+1"><PRE><font color=#009900>//: C06:ExplicitInstantiation.cpp</font>
<font color=#009900>//{L} ../TestSuite/Test</font>
<font color=#009900>//{-g++295}</font>
<font color=#009900>//{-msc}</font>
#include <font color=#004488>"Urand.h"</font>
#include <font color=#004488>"Sorted.h"</font>
#include &lt;iostream&gt;
<font color=#0000ff>using</font> <font color=#0000ff>namespace</font> std;

<font color=#009900>// Explicit instantiation:</font>
<font color=#0000ff>template</font> <font color=#0000ff>class</font> Sorted&lt;<font color=#0000ff>int</font>&gt;;

<font color=#0000ff>int</font> main() {
  Sorted&lt;<font color=#0000ff>int</font>&gt; is;
  Urand&lt;47&gt; rand1;
  <font color=#0000ff>for</font>(<font color=#0000ff>int</font> k = 0; k &lt; 15; k++)
    is.push_back(rand1());
  is.sort();
  <font color=#0000ff>for</font>(<font color=#0000ff>int</font> l = 0; l &lt; is.size(); l++)
    cout &lt;&lt; is[l] &lt;&lt; endl;
} <font color=#009900>///:~</font></PRE></FONT></BLOCKQUOTE>
<DIV ALIGN="LEFT"><P><FONT FACE="Georgia">In this example, the explicit
instantiation doesn&#8217;t really accomplish anything; the program would work
the same without it. Explicit instantiation is only for special cases where
extra control is needed.</FONT><A NAME="_Toc519041999"></A><BR></P></DIV>
<A NAME="Heading178"></A><FONT FACE = "Verdana, Tahoma, Arial, Helvetica, Sans"><H3 ALIGN="LEFT">
Explicit specification of template functions<A NAME="_Toc519042000"></A></H3></FONT>
<A NAME="Heading179"></A><FONT FACE = "Verdana, Tahoma, Arial, Helvetica, Sans"><H2 ALIGN="LEFT">
Controlling template instantiation</H2></FONT>
<DIV ALIGN="LEFT"><P><FONT FACE="Georgia">Normally templates are not instantiated
until they are needed. For function templates this just means the point at which
you call the function, but for class templates it&#8217;s more granular than
that: each individual member function of the template is not instantiated until
the first point of use. This means that only the member functions you actually
use will be instantiated, which is quite important since it allows greater
freedom in what the template can be used with. For example:</FONT><BR></P></DIV>

<BLOCKQUOTE><FONT SIZE = "+1"><PRE><font color=#009900>//: C06:DelayedInstantiation.cpp</font>
<font color=#009900>// Member functions of class templates are not</font>
<font color=#009900>// instantiated until they're needed.</font>
<font color=#009900>//{L} ../TestSuite/Test</font>

<font color=#0000ff>class</font> X {
<font color=#0000ff>public</font>:
  <font color=#0000ff>void</font> f() {}
};

<font color=#0000ff>class</font> Y {
<font color=#0000ff>public</font>:
  <font color=#0000ff>void</font> g() {}
};

<font color=#0000ff>template</font> &lt;<font color=#0000ff>typename</font> T&gt; <font color=#0000ff>class</font> Z {
  T t;
<font color=#0000ff>public</font>:
  <font color=#0000ff>void</font> a() { t.f(); }
  <font color=#0000ff>void</font> b() { t.g(); }
};

<font color=#0000ff>int</font> main() {
  Z&lt;X&gt; zx;
  zx.a(); <font color=#009900>// Doesn't create Z&lt;X&gt;::b()</font>
  Z&lt;Y&gt; zy;
  zy.b(); <font color=#009900>// Doesn't create Z&lt;Y&gt;::a()</font>
} <font color=#009900>///:~</font></PRE></FONT></BLOCKQUOTE>
<DIV ALIGN="LEFT"><P><FONT FACE="Georgia">Here, even though the template purports
to use both <B>f(&#160;)</B> and <B>g(&#160;)</B> member functions of <B>T</B>,
the fact that the program compiles shows you that it only generates
<B>Z&lt;X&gt;::a(&#160;)</B> when it is explicitly called for <B>zx</B> (if
<B>Z&lt;X&gt;::b(&#160;)</B> were also generated at the same time, a
compile-time error message would be generated). Similarly, the call to
<B>zy.b(&#160;)</B> doesn&#8217;t generate <B>Z&lt;Y&gt;::a(&#160;)</B>. As a
result, the <B>Z</B> template can be used with