Template Mania

Environment: VC6 SP5, NT4 SP3, Windows 98, Windows 2000

There is an interesting article concerning template-based technique on www.cuj.com [1]. A simple struct is introduced there that helps to implement dummy arguments converting values to distinquishable types:

template<int v>
struct Int2Type
   enum { value = v };
The main article idea is generally described in terms of classes, but there is a reason why it can be especially useful for template functions with VC. There is a bug Q240871 in the Microsoft Visual C++ 6.0 compiler, its description from the MSDN is given below:


If all the template parameters are not used in function arguments or return type of a template function, the template functions are not overloaded correctly.


The bug is the result of the way the compiler decorates template function names. Name Decoration uses the arguments and return type and doesn't use the explicitly specified template argument type. Therefore, all three template function instantiations receive the same decorated name<...>


Use dummy arguments to the function.

There is another interesting technique outlined in [2]. Templates do not deal with objects hierarchy, but dummy arguments combined with ellipses make it possible to specialize templates for classes and their subclasses. Let us implement a pointer validity checking utility based on these principles as an example.

MFC has two validating macros: ASSERT_VALID for CObject-based classes and ASSERT_POINTER for others. We introduce a single template function that supersedes both of them. The whole stuff being workable, some details will be omitted for simplicity. ASSERT_VALID macro invokes AfxAssertValidObject(). Among other things, it checks the object virtual table pointer. To do so, we need to find out if the class has one first. The next accessory struct can help us:

template<class T> struct HasVirtualTable
   class X : public T
      virtual void dummy();
   enum { has_table = sizeof(X) == sizeof(T) };
Then we introduce an AssertVTable template function for the "TRUE" and its void specialization for the "FALSE" (0) Int2Type template parameter:
template<typename T> inline void AssertVTable(const void* pData, T)
  ASSERT(AfxIsValidAddress(*(void**)pData, sizeof(void*), FALSE));

inline void AssertVTable(const void*, Int2Type<0>) {}
Here goes the common validating routine with an ellipse at the end of the arguments list:
template<class T> inline void AssertValidPointer(const T* pData, ...)
  ASSERT(AfxIsValidAddress(pData, sizeof(T)));
The next validating routine substitutes the previous one for CObject subclasses:
template<class T> inline void AssertValidPointer(const T* pOb,
                                                      const CObject*)
  ASSERT(AfxIsValidAddress(pOb, sizeof(T)));
  ASSERT(AfxIsValidAddress(*(void**)pOb, sizeof(void*), FALSE));
We can add customized validating routine for any class hierarchy branch in the same way.

Here are the top level functions to be used in the application:

template<class T> inline void CHECK_ADDRESS(const T* pData)
  AssertValidPointer(pData, pData);
template<class T> inline void CHECK_NULL_OR_ADDRESS(const T* pData)
  if(NULL != pData)
     AssertValidPointer(pData, pData);
We put stuff listed above into the #if/#else/#endif brackets to disable the functionality in the release build:
#ifdef _DEBUG
#else //_DEBUG
#define CHECK_ADDRESS(pData)          ((void)0)
#define CHECK_NULL_OR_ADDRESS(pData)  ((void)0)
#endif //!_DEBUG
Now we can use the CHECK_ADDRESS() and CHECK_NULL_OR_ADDRESS() functions.

At the end of the article I would dare to propose an exotic way to simulate enums using templates. It was written for fun only, but seems to be interesting and can actually help when there is no other way to keep enum items together:

#include <iostream>

#define ENUM(val) \
template<> struct cnt<__LINE__> { enum {v = cnt<__LINE__-1>::v+1}; }; \
enum { val = cnt<__LINE__>::v };	\
template<> struct flg<val> { enum {v = 0}; };

namespace test
  template<int i> struct flg { enum {v = -1}; };
  template<int i> struct cnt { enum {v = cnt<i-1>::v }; };
  template<> struct cnt<__LINE__> { enum {v = -1 }; };


// Some stuff here


// Some stuff here


  template<int i> struct bnd 
        u = bnd<(i+1) | flg<i+1>::v>::v,
        v = (-1 == u)? i : u
  template<> struct bnd<-1> { enum { v = -1 }; };
  enum { upper_bound = (bnd<0>::v | flg<0>::v)+1 };

int main()
  cout << test::a << ',' 
       << test::b << ',' 
       << test::c << ',' 
       << test::upper_bound << "\n";
  return 0;


[1] Andrei Alexandrescu "Generic Programming: Mappings between Types and Values"

[2] "Template Overloading For Base Class Pointers", by Don Wong


  • There are no comments yet. Be the first to comment!

Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • Live Event Date: December 11, 2014 @ 1:00 p.m. ET / 10:00 a.m. PT Market pressures to move more quickly and develop innovative applications are forcing organizations to rethink how they develop and release applications. The combination of public clouds and physical back-end infrastructures are a means to get applications out faster. However, these hybrid solutions complicate DevOps adoption, with application delivery pipelines that span across complex hybrid cloud and non-cloud environments. Check out this …

  • CentreCorp is a fully integrated and diversified property management and real estate service company, specializing in the "shopping center" segment, and is one of the premier retail service providers in North America. Company executives travel a great deal, carrying a number of traveling laptops with critical current business data, and no easy way to back up to the network outside the office. Read this case study to learn how CentreCorp implemented a suite of business continuity services that included …

Most Popular Programming Stories

More for Developers

RSS Feeds