Question

I’ve seen qualified used in the context cv-qualifiers:

unqualified types can be implicitly converted to const

But I’ve also seen qualified used to mean any nested type:

MyClass::MyNestedType x;

---

What are other homonymic terms from the language standard?

Answer 1

For an addressing of the two meanings of qualification, see below…

Well, after seeing the real intended question here goes:

• const, mutable (for functions)
• delete
  • for destruction+freeing dynamically allocated objects or
  • for prohibiting auto-generated special class members)
• auto
  • formerly declspec for stack/static variables;
  • in c++11 the ‘inferred type’ specifier
• virtual
  • for virtual member functions or
  • for virtual base classes
• using
  • for defining a namespace alias (sic)
  • for importing a namespace
  • for importing a qualified name into the current namespace
    • note that this does NOT mean that the imported name is going to be used; it just means that the compiler will be aware of the imported declaration when starting overload resolution. This may result in SFINAE kicking in and selecting a whole different overload/specialization from yet another namespace. Confusing!
  • for importing a name from a base class into the derived class (to prevent false name hiding)

Syntax nits:

• & for addressof or for reference type (debatable – not very confusing)
• [] for array indexing or for lambda declaration

• >> for right-shift or for closing a nested template definition

  pop-quiz: what is this: 
  
      template <size_t> struct X {};
      std::vector<X<3>> a; // valid? invalid?
  

• most vexing parse:

      std::istream_iterator<int> first(std::cin); // declares a variable
      std::istream_iterator<int> last();          // declares a function
  

Etc.

---

Meanings of Qualification

(original response)

The first is ‘const/volatile’ qualification

A variable/function/parameter declaration includes a type. This type can be ‘const’ or ‘volatile’ qualified to modify the semantics of the type.

The second is namespace qualification

C++ can group names into namespaces, to avoid clashes. The unqalified name is enough to refer to identifiers declared in the current or visible namespaces:

namespace ns1
{
    struct X {};
    X f();
}

using namespace ns1;
X f2();

However to

• refer to names outside the current/visible namespace(s)
• disambiguate conflicting visible declarations in multiple namespaces

you’ll have to use what’s known as the ‘qualified’ name:

struct X {} ;
namespace ns2
{
    struct X {};
    ns2::X f();
    ns1::X g();
}

X h(); // uses ::X

using namespace ns2;

::X i();    // disambiguate
ns2::X i();