C++ Template Metaprogramming/

...

/

Understanding Name Binding and Dependent Names

Understanding Name Binding and Dependent Names

Learn about name binding and its various categories.

We'll cover the following...

Kinds of names used within templates

The term name binding refers to the process of finding the declaration of each name that is used within a template. There are two kinds of names used within a template: dependent names and nondependent names. The former are names that depend on the type or value of a template parameter that can be a type, non-type, or template parameter. Names that don’t depend on template parameters are called nondependent. The name lookup is performed differently for dependent and nondependent names:

  • For dependent names, it’s performed at the point of template instantiation.

  • For nondependent names, it’s performed at the point of the template definition.

We’ll first look at nondependent names. As previously mentioned, name lookup happens at the point of the template definition. This is located immediately before the template definition. To understand how this works, let’s consider the following example:

Press + to interact
template<typename T>
struct processor;             // Template declaration
void handle(double value)     // The handle(double) definition
{
   std::cout << "Processing a double: " << value << '\n';
}
template<typename T>
struct parser                 // Template definition
{
   void parse()
   {
       handle(42);            // Nondependent name
   } 
};
void handle(int value)        // The handle(int) definition
{
   std::cout << "Processing an int: " << value << '\n';
}
int main()
{
   parser<int> p;             // Template instantiation
   p.parse();
}

There are several points of reference that are marked in the comments on the right side. At line 2, we have the declaration of a class template called parser. This is followed at line 4 by the definition of a function called handle that takes a double as its argument. The definition of the class template follows at line 10. This class contains a single method called parse that invokes a function called handle with the value 42 as its argument at line 14.

The name handle is a nondependent name because it does not depend on any template parameter. Therefore, name lookup and binding are performed at this point. handle must be a function known at line 10, and the function defined at line 4 is the only match. After the class template definition, at line 18 we have the definition of an overload for the handle function, which takes an integer as its argument. This is a better match for handle(42), but it comes after the name binding has been performed, and therefore, it will be ignored. In the main function, at line 25, we have an instantiation of the parser class template for the type int. Upon calling the parse function, the text processing a double: 42 will be printed to the console output.

The next example is designed to introduce us to the concept of dependent names. Let’s look at the code first:

Press + to interact
template<typename T>
struct handler                // Template definition
{
   void handle(T value)
   {
      std::cout << "handler<T>: " << value << '\n';
   }
};
template<typename T>
struct parser                 // Template definition
{
   void parse(T arg)
   {
      arg.handle(42);         // Dependent name
   } 
};
template<>
struct handler<int>           // Template specialization
{
   void handle(int value)
   {
      std::cout << "handler<int>: " << value << '\n';
   }
};
int main() {
   handler<int> h;            // Template instantiation
   parser<handler<int>> p;    // Template instantiation
   p.parse(h);
}

This example is slightly different from the previous one. The parser class template is very similar, but the handle functions have become members of another class template. Let’s analyze it point by point.

At line 2, we have the definition of a class template called handler. This contains a single public method called handle that takes an argument of the T type and prints its value to the console. Next, at line 11, we have the definition of the class template called parser. This is similar to the previous one, except for one key aspect: at line 15, it invokes a method called handle on its argument. Because the type of the argument is the template parameter T, it makes handle a dependent name. Dependent names are looked up at the point of template instantiation, so handle is not bound at ...