Why in a template we can use a dependent name without being already declared if not instantiated?

Question

I have written this code to understand template name lookup:

//void bar(int);

template <typename T>
void foo(T x)
{
    bar(x);
}

void bar(int x)
{
    std::cout << "bar(int)\n";
}

template <int>
void foo(int i)
{
    bar(i);
}



int main()
{

    foo<int>(4);


    std::cout << "\ndone!\n";
}

I've commented out the declaration of function bar(int) intentionally. This function bar(int) is used as a dependent name in the template function foo. So it is bound upon instantiation.

I've defined bar right after foo and before a specialization of foo<int> so that this latter can see bar(int).

But when I compile the code I get this error:

‘bar’ was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation [-fpermissive]|. And if I un-comment the declaration of bar(int) it works fine?!

If I must declare a name before using it in a template as a dependent-name then why C++ allows that if not instantiated. (the code works if I don't "use" templated function foo)?
```
  template <typename U>
  void do_it(U u)
  {
      print(u); // not bound until instantiation
  }
```

So what is the idea behind allowing calling print(u) in do_it which was not already declared and will fail upon instantiation?

`print(u)` is not actually allowed. It's just that you don't necessarily get an error message. — cigien, Oct 25 '20 at 21:16
@idclev463035818: Because it uses the template parameter type. — Maestro, Oct 25 '20 at 21:21
Hmm, I think I see where part of your confusion lies. You don't have a specialization of `foo` at all. You're declaring a completely different entity. You need `template<> void foo(int i);` The code is fine then. — cigien, Oct 25 '20 at 21:28

cigien · Accepted Answer · 2020-10-25T21:44:58.783

In your program, this definition:

template <int>     // not a specialization, just a different
void foo(int i)    // template with a non-type template parameter
{
    bar(i);
}

does not actually define a specialization of the foo primary template. So when you make this call:

Foo<int>(4);

you end up calling the primary template. Lookup for the name bar doesn't find that name, and you get an error.

If instead, you actually write a specialization of foo for int like this:

template <>           // specialization of primary
void foo<int>(int i)  // template foo with int
{
    bar(i);
}

then the call foo<int>(4); is fine, because it calls the specialization, and lookup for bar at that point does find that name.

Now going back to your program (without the specialization), what happens if foo is never instantiated, because there's no call, for example? Well, the program is still wrong, but the compiler may not tell you about it. This is the behavior that you are describing with print and do_it, and this is formally known as ill-formed, no diagnostic required.

score 1 · Answer 2 · answered Oct 25 '20 at 21:31

1

Pay attention to the line numbers in that error output.

You’re instantiating the first template. The second template is not a specification of the first but a function template that requires an int template parameter that it doesn’t use.

answered Oct 25 '20 at 21:31

Timothy Brackett

151
6

Thank you! what you mean with error numbers in the output? – Maestro Oct 25 '20 at 22:07
2

Warnings and errors typically have line numbers associated with them. `file.cpp:128` for example is the 128th line of `file.cpp`. – Timothy Brackett Oct 25 '20 at 22:15

Why in a template we can use a dependent name without being already declared if not instantiated?

2 Answers2