Why does the following templated class member function not compile?

Question

The following code compiles even though nonexisting_func() doesn't exist. The code compiles because it's a member function of a templated class, but the function itself is not compiled because it's not being used in the program, correct? So you could have any syntax errors inside heapify_down and the entire code should still compile?

#include <iostream>
#include <vector>

template<typename T>
class heap
{
public:
   void heapify_down(std::vector<T> &vec)
   {
      nonexisting_func(vec);
   }
};

int main( ) 
{ 
   heap<int> my_heap;
   return 0;
}

If my understanding above is correct, then why does the following code not compile?

#include <iostream>
#include <vector>

template<typename T>
class heap
{
public:
   void heapify_down(std::vector<T> &vec)
   {
      a;
      nonexisting_func(vec);
   }
};

int main( ) 
{ 
   heap<int> my_heap;
   return 0;
}

Compiling this code gives me the error error: use of undeclared identifier 'a'. Why is it trying to compile the heapify_down() function now?

Answer 1

Template code basically has two passes that it goes through. The first pass just looks at the code and makes sure that it is syntactically correct, and that any non-dependent code is correct. By non-dependent code, I mean code that does not depend on the template parameter(s).

After that there is a second pass that happens after the template is actually instantiated. At that point there is no more dependent code as all the template parameters are known and the compiler can exam the code like it would for any non-template code.

In

void heapify_down(std::vector<T> &vec)
{
    nonexisting_func(vec);
}

The call to nonexisting_func depends on vec because of ADL and vec depends on T so it's compilation is deferred. It is syntactically correct so it wont have any further checking done until it is instantiated. If you changed main to

int main( ) 
{ 
   std::vector<int> foo;
   heap<int> my_heap;
   my_heap.heapify_down(foo);
   return 0;
}

So that heapify_down is actually instantiated then you would get a compiler error like

main.cpp:22:7: error: use of undeclared identifier 'nonexisting_func'
      nonexisting_func(vec);
      ^
main.cpp:30:12: note: in instantiation of member function 'heap<int>::heapify_down' requested here
   my_heap.heapify_down(foo);
           ^
1 error generated.

You would also get an error using

void heapify_down(std::vector<T> &vec)
{
    ::nonexisting_func(vec);
}

Because now we are no longer have an unqualified name so ADL is ignored meaning ::nonexisting_func is no longer a dependent name.

With

void heapify_down(std::vector<T> &vec)
{
   a;
   nonexisting_func(vec);
}

a doesn't depend on T so the compiler tries to look it up. It can't find it, so you get an error. If you had instead done

void heapify_down(std::vector<T> &vec)
{
   this->a;
   nonexisting_func(vec);
}

then again you would not get an error until you instantiate the function since a now depends on this and this depends on T.

Answer 2

The key point here is that nonexisting_func(vec); is going to mean something different depending on what T is (since vec is a vector<T>).

So in that case, the compiler cannot try to resolve the call to nonexisting_func() immediately as it lexes the function, and can only do so when comes the time to instantiate the template (which you never do).

In the case of a, since that identifier doesn't depend on anything, the compiler should perform the lookup immediately. I say should because MSVC in particular tends to still delay the lookup until instantiation, even though it shouldn't on paper.