unqualified name in template

Hello everyone,


About Bjarne's statement in section C.13.8.3 Point of Instantiation Binding, I have made some further thinking and coding. Here are my two questions.

--------------------
Nor can an unqualified name used in a template ever be bound to a local name.
--------------------

1. Sometimes we use qualified name in template? I have never usage of qualified names in template. Does Bjarne means some code like this, Does such use rare?

(suppose Foo is a template class)

Foo<::myType> or Foo<Somenamespace::myType> or Foo<SomeClass::myType>

2,

Does Bjarne indicate qualified names used in a template coule be bound to a local name? For example, we define a local namespace, put a struct in the local namespace, then we could use localNameSpace::strctInLocalNameSpace to instantise the template?

Puesdu code like this.

Code:

---

void f()
{
// inside local function f
namespace localns {
    struct foo;
};
vector<localns::foo> vc;
}

---

thanks in advance,
George

1) Yes, qualified names are used a lot in templates. Don't confuse it with using qualified names to instantiate templates. That's nothing to with it.

Code:

---

template <typename T>
void Foo<T>::bar()
{
  // Make frobnicate a dependent name so that it is found in the template super class.
  this->frobnicate();
}

---

2) There's no qualified name that can be used to refer to a local name. And refer to what I pointed out about your confusion in point #1.

Thanks CornedBee,


Just want to clarify one thing, what do you mean using qualified in a template.

1. Do you mean using qualified name in template (function or class) definition -- as your sample showing below;
2. Do you mean using qualified name when we use template (i.e. instantiatise) to bind the qualified name to template parameter?
3. Or both?

If you mean (1), here is Bjarne's original words,

--------------------
Nor can an unqualified name used in a template ever be bound to a local name.
--------------------

During template definition, there is no name binding I think. I think Bjarne should mean during template use -- case (2)?

Quote:

---

Originally Posted by CornedBee

1) Yes, qualified names are used a lot in templates. Don't confuse it with using qualified names to instantiate templates. That's nothing to with it.

Code:

---

template <typename T>
void Foo<T>::bar()
{
  // Make frobnicate a dependent name so that it is found in the template super class.
  this->frobnicate();
}

---

2) There's no qualified name that can be used to refer to a local name. And refer to what I pointed out about your confusion in point #1.

---

regards,
Geroge

I mean (1) - I thought my example made that obvious.

Bjarne means template definition. There is name binding there - two-stage name binding, in fact, which is the topic of this thread.

There is absolutely nothing special about explicit template parameters when instantiating a template.

Thanks CornedBee,


What do you mean nothing special? Both qualified name and unqualified name can be used to instantise a template?

Quote:

---

Originally Posted by CornedBee

There is absolutely nothing special about explicit template parameters when instantiating a template.

---

regards,
George

Nothing special. No special rules. No special effects. It absolutely doesn't matter if you use qualified names or unqualified names, beyond the usual.

Well, unless you're doing the instantiating inside the definition of a template, in which case those special rules apply.

Thanks CornedBee,


How could we instantise a template in its definition? I am conrfused. Could you show some pseudo code please?

Quote:

---

Originally Posted by CornedBee

Well, unless you're doing the instantiating inside the definition of a template, in which case those special rules apply.

---

regards,
George

Not in "its" definition. In "a" definition. (Not that the other isn't possible as well, as long as it's another instantiation.)

Code:

---

template <typename T> bar()
{
  // Note: both func and foo are unqualified and dependent.
  foo(func(T()));
}

template <typename T> void foo(T t) { ... }

template <typename T>
typename some_meta_function<T>::type func(T t) { ... }

---

Thanks CornedBee,


Do you mean in template function bar, when it is instantised, we also instantise foo and func at the same time from template function bar?

Quote:

---

Originally Posted by CornedBee

Not in "its" definition. In "a" definition. (Not that the other isn't possible as well, as long as it's another instantiation.)

Code:

---

template <typename T> bar()
{
  // Note: both func and foo are unqualified and dependent.
  foo(func(T()));
}

template <typename T> void foo(T t) { ... }

template <typename T>
typename some_meta_function<T>::type func(T t) { ... }

---

---

regards,
George

Yes.

Thanks CornedBee,


Question answered.

Quote:

---

Originally Posted by CornedBee

Yes.

---

regards,
George