1

I am learning about templates in C++ and so trying out different examples. One such example whose output i am unable to understand is given below:

template<typename T> void func(T p) {
g<T>(p); //ERROR
g(p);    //NO ERROR?
}


int main()
{

}

When i try to compile the above code snippet, i get error saying:

prog.cc: In function 'void func(T)':
prog.cc:2:1: error: 'g' was not declared in this scope
    2 | g<T>(p); //ERROR
      | ^
prog.cc:2:4: error: expected primary-expression before '>' token
    2 | g<T>(p); //ERROR
      |    ^

My questions are:

  1. Why i am getting this error?
  2. Why i am getting the error only for the statement g<T>(p); and not for g(p);? I thought that writing g(p); is equivalent to g<T>(p); since due to template argument deduction the template parameter for g will be deduced to T.
Improve this question
2
  • unless g is also a templated function or class, compiler shall not know what g<T> means at that point. look up SFINAE for some justification on the behavior- it makes for some very powerful compile-time capabilities. Commented Feb 16, 2022 at 13:31
  • g(p); might be found by ADL. For template notation case, any (but with same name) previous template declaration would be enough. Commented Feb 16, 2022 at 13:36

2 Answers 2

Reset to default
1

template uses a Two-phase name lookup.

First, at the point of the template definition, the template is checked for syntax.

and so g(p); is correct (from syntax point of view) (assuming a function g found by ADL).

For g<T>(p);, we have (until C++20):

Although a function call can be resolved through ADL even if ordinary lookup finds nothing, a function call to a function template with explicitly-specified template arguments requires that there is a declaration of the template found by ordinary lookup (otherwise, it is a syntax error to encounter an unknown name followed by a less-than character)

g<T>(p); is not correct, (as parsed only as (g < T) > p; (T is a type, so it is wrong)).

If there exists any template function g, then g might be considered as template, and code would be correct from syntax point of view (even if template parameter won't match).

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

0

Case 1

Here we consider the statement: g<T>(p);

template<typename T> void func(T p) {
g<T>(p); //ERROR
}
int main()
{

}

In the above code snippet the name g is a unqualified dependent name. And from source: two phase lookup:

During the first phase, while parsing a template unqualified dependent names are looked up using the ordinary lookup rules. For unqualified dependent names, the initial ordinary lookup—while not complete—is used to decide whether the name is a template.

Now lets apply this to the statement g<T>(p);. When parsing the function template func, the statement g<T>(p); is encountered. Since g is a dependent qualified name, according to the above quoted statement, the name g is looked up using ordinary lookup rules. This is so that the compiler can decide whether the name g is a template. But since there is no declaration for a function template named g before this point, the first angle bracket < is treated as a less than symbol and hence produces the error you mentioned. Also, note that ADL is done in second phase. But for that to happen we must first successfully parse the generic definition of function func.[source: C++ Templates: The Complete guide: Page 250 second last paragraph]

Note that compilers are allowed to delay error until instantiation which is why some compilers compiles your code without any error. Demo.

Case 2

Here we consider the statement g(p);.

template<typename T> void func(T p) {
g(p); // NO ERROR
}
int main()
{

}

In this case also, the name g is an unqualified dependent name. So according to the quoted statement from the beginning of my answer, the name g is looked up using ordinary lookup rules. But since there is no g visible at this point we have an error. There are two things to note here:

  1. Since this time you have not explicitly(by using the angle brackets) called g, there is no syntax error.
  2. And since there are no syntax error in this case and there are no POI for func in your program, so here there are no errors to delay and the program compiles fine. However, if you instantiate func then you'll get error at instantiation time saying g was not declared.
Improve this answer

7 Comments

Notice that in case 2, there are no errors to delay. And it is really at the instantiation that error might occurs, (as g might be properly declared/defined later for such type).
@Jarod42 Can you elaborate on why there are no errors to delay in case 2. I mean since during the first phase(for g(p);) when it is found that there is no visible g so shouldn't this be an error saying g was not declared?
There is ADL, so void g(MyObject){} can be declared after. (especially if g is a point of customization). and so h(MyObject{}); would be fine Demo.
And Demo for valid g<T>(p) call with unrelated previous template g function.
First phase of two-phase_lookup just checks syntax. and from ADL, since C++20, Case 1 is not a syntax error neither.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.