1: template <typename Type> // this is the template parameter declaration

   2: Type max(Type tX, Type tY)

   3: {

   4:     return (tX > tY) ? tX : tY;

   5: }

   1: int nValue = max(3, 7); // calls max(int, int)

   1: int max(int tX, int tY)

   2: {

   3:     return (tX > tY) ? tX : tY;

   4: }

   1: template <typename T, int nSize> // nSize is the expression parameter

   2: class Buffer

   3: {

   4: private:

   5:     // The expression parameter controls the size of the array

   6:     T m_atBuffer[nSize];

   7:  

   8: public:

   9:     T* GetBuffer() { return m_atBuffer; }

  10:  

  11:     T& operator[](int nIndex)

  12:     {

  13:         return m_atBuffer[nIndex];

  14:     }

  15: };

  16:  

  17: int main()

  18: {

  19:     // declare an integer buffer with room for 12 chars

  20:     Buffer<int, 12> cIntBuffer;

  21:  

  22:     // Fill it up in order, then print it backwards

  23:     for (int nCount=0; nCount < 12; nCount++)

  24:         cIntBuffer[nCount] = nCount;

  25:  

  26:     for (int nCount=11; nCount >= 0; nCount--)

  27:         std::cout << cIntBuffer[nCount] << " ";

  28:     std::cout << std::endl;

  29:  

  30:     // declare a char buffer with room for 31 chars

  31:     Buffer<char, 31> cCharBuffer;

  32:  

  33:     // strcpy a string into the buffer and print it

  34:     strcpy(cCharBuffer.GetBuffer(), "Hello there!");

  35:     std::cout << cCharBuffer.GetBuffer() << std::endl;

  36:  

  37:     return 0;

  38: }

   1: using namespace std;

   2:  

   3: template <typename T>

   4: class Storage

   5: {

   6: private:

   7:     T m_tValue;

   8: public:

   9:     Storage(T tValue)

  10:     {

  11:          m_tValue = tValue;

  12:     }

  13:  

  14:     ~Storage()

  15:     {

  16:     }

  17:  

  18:     void Print()

  19:     {

  20:         std::cout << m_tValue << std::endl;;

  21:     }

  22: };

   1: int main()

   2: {

   3:     using namespace std;

   4:  

   5:     // Dynamically allocate a temporary string

   6:     char *strString = new char[40];

   7:  

   8:     // Ask user for their name

   9:     cout << "Enter your name: ";

  10:     cin >> strString;

  11:  

  12:     // Store the name

  13:     Storage<char*> strValue(strString);

  14:  

  15:     // Delete the temporary string

  16:     delete strString;

  17:  

  18:     // Print out our value

  19:     strValue.Print(); // This will print garbage

  20: }

   1: Storage<char*>::Storage(char* tValue)

   2: {

   3:      m_tValue = tValue;

   4: }

   1: Storage<char*>::Storage(char* tValue)

   2: {

   3:     // Allocate memory to hold the tValue string

   4:     m_tValue = new char[strlen(tValue)+1];

   5:     // Copy the actual tValue string into the m_tValue memory we just allocated

   6:     strcpy(m_tValue, tValue);

   7: }

   1: Storage<char*>::~Storage()

   2: {

   3:     delete[] m_tValue;

   4: }

   1: template <typename T>

   2: class Storage8

   3: {

   4: private:

   5:     T m_tType[8];

   6:  

   7: public:

   8:     void Set(int nIndex, const T &tType)

   9:     {

  10:         m_tType[nIndex] = tType;

  11:     }

  12:  

  13:     const T& Get(int nIndex)

  14:     {

  15:         return m_tType[nIndex];

  16:     }

  17: };

   1: template <> // the following is a template class with no templated parameters

   2: class Storage8<bool> // we're specializing Storage8 for bool

   3: {

   4: // What follows is just standard class implementation details

   5: private:

   6:     unsigned char m_tType;

   7:  

   8: public:

   9:     void Set(int nIndex, bool tType)

  10:     {

  11:         // Figure out which bit we're setting/unsetting

  12:         // This will put a 1 in the bit we're interested in turning on/off

  13:         unsigned char nMask = 1 << nIndex;

  14:  

  15:         if (tType)  // If we're setting a bit

  16:             m_tType |= nMask;  // Use bitwise-or to turn that bit on

  17:         else  // if we're turning a bit off

  18:             m_tType &= ~nMask;  // bitwise-and the inverse mask to turn that bit off

  19:     }

  20:  

  21:     bool Get(int nIndex)

  22:     {

  23:         // Figure out which bit we're getting

  24:         unsigned char nMask = 1 << nIndex;

  25:         // bitwise-and to get the value of the bit we're interested in

  26:         // Then implicit cast to boolean

  27:         return m_tType & nMask;

  28:     }

  29: };