[basic.namespace] - C++11 → C++14

Files changed (1) hide show

tmp/tmp24_cnded/{from.md → to.md} +40 -33

tmp/tmp24_cnded/{from.md → to.md} RENAMED Viewed

@@ -147,11 +147,11 @@ An *unnamed-namespace-definition* behaves as if it were replaced by
 ```
 where `inline` appears if and only if it appears in the
 *unnamed-namespace-definition*, all occurrences of *unique* in a
 translation unit are replaced by the same identifier, and this
-identifier differs from all other identifiers in the entire program.[^6]
 ``` cpp
 namespace { int i; }            // unique ::i
 void f() { i++; }               // unique ::i++
@@ -205,29 +205,31 @@ namespace R {
   void Q::V::g() { /* ... */ }  // error: R doesn't enclose Q
 }
 ```
 Every name first declared in a namespace is a member of that namespace.
-If a `friend` declaration in a non-local class first declares a class or
-function[^7] the friend class or function is a member of the innermost
-enclosing namespace. The name of the friend is not found by unqualified
-lookup ([[basic.lookup.unqual]]) or by qualified lookup (
-[[basic.lookup.qual]]) until a matching declaration is provided in that
-namespace scope (either before or after the class definition granting
-friendship). If a friend function is called, its name may be found by
-the name lookup that considers functions from namespaces and classes
-associated with the types of the function arguments (
-[[basic.lookup.argdep]]). If the name in a `friend` declaration is
-neither qualified nor a *template-id* and the declaration is a function
-or an *elaborated-type-specifier*, the lookup to determine whether the
-entity has been previously declared shall not consider any scopes
-outside the innermost enclosing namespace. The other forms of `friend`
-declarations cannot declare a new member of the innermost enclosing
-namespace and thus follow the usual lookup rules.
 ``` cpp
-// Assume f and g have not yet been defined.
 void h(int);
 template <class T> void f2(T);
 namespace A {
   class X {
     friend void f(X);           // A::f(X) is a friend
@@ -318,12 +320,12 @@ specified name is so declared; specifying an enumeration name in a
 *using-declaration* does not declare its enumerators in the
 *using-declaration*’s declarative region. If a *using-declaration* names
 a constructor ([[class.qual]]), it implicitly declares a set of
 constructors in the class in which the *using-declaration* appears (
 [[class.inhctor]]); otherwise the name specified in a
-*using-declaration* is a synonym for the name of some entity declared
-elsewhere.
 Every *using-declaration* is a *declaration* and a *member-declaration*
 and so can be used in a class definition.
 ``` cpp
@@ -457,14 +459,16 @@ struct X : B {
   using B::i;
   using B::i;       // error: double member declaration
 };
 ```
-The entity declared by a *using-declaration* shall be known in the
-context using it according to its definition at the point of the
-*using-declaration*. Definitions added to the namespace after the
-*using-declaration* are not considered when a use of the name is made.
 ``` cpp
 namespace A {
   void f(int);
 }
@@ -526,17 +530,20 @@ void func() {
   struct x x1;      // x1 has class type B::x
 }
 ```
 If a function declaration in namespace scope or block scope has the same
-name and the same parameter types as a function introduced by a
-*using-declaration*, and the declarations do not declare the same
-function, the program is ill-formed. Two *using-declaration*s may
-introduce functions with the same name and the same parameter types. If,
-for a call to an unqualified function name, function overload resolution
-selects the functions introduced by such *using-declaration*s, the
-function call is ill-formed.
 ``` cpp
 namespace B {
   void f(int);
   void f(double);
@@ -559,11 +566,11 @@ void h() {
 When a *using-declaration* brings names from a base class into a derived
 class scope, member functions and member function templates in the
 derived class override and/or hide member functions and member function
 templates with the same name, parameter-type-list ([[dcl.fct]]),
 cv-qualification, and *ref-qualifier* (if any) in a base class (rather
-than conflicting). For *using-declarations* that name a constructor,
 see  [[class.inhctor]].
 ``` cpp
 struct B {
   virtual void f(int);
@@ -794,11 +801,11 @@ transitive search is unordered. In particular, the order in which
 namespaces were considered and the relationships among the namespaces
 implied by the *using-directive*s do not cause preference to be given to
 any of the declarations found by the search. An ambiguity exists if the
 best match finds two functions with the same signature, even if one is
 in a namespace reachable through *using-directive*s in the namespace of
-the other.[^8]
 ``` cpp
 namespace D {
   int d1;
   void f(char);

 ```
 where `inline` appears if and only if it appears in the
 *unnamed-namespace-definition*, all occurrences of *unique* in a
 translation unit are replaced by the same identifier, and this
+identifier differs from all other identifiers in the entire program.[^5]
 ``` cpp
 namespace { int i; }            // unique ::i
 void f() { i++; }               // unique ::i++
   void Q::V::g() { /* ... */ }  // error: R doesn't enclose Q
 }
 ```
 Every name first declared in a namespace is a member of that namespace.
+If a `friend` declaration in a non-local class first declares a class,
+function, class template or function template[^6] the friend is a member
+of the innermost enclosing namespace. The `friend` declaration does not
+by itself make the name visible to unqualified lookup (
+[[basic.lookup.unqual]]) or qualified lookup ([[basic.lookup.qual]]).
+The name of the friend will be visible in its namespace if a matching
+declaration is provided at namespace scope (either before or after the
+class definition granting friendship). If a friend function or function
+template is called, its name may be found by the name lookup that
+considers functions from namespaces and classes associated with the
+types of the function arguments ([[basic.lookup.argdep]]). If the name
+in a `friend` declaration is neither qualified nor a *template-id* and
+the declaration is a function or an *elaborated-type-specifier*, the
+lookup to determine whether the entity has been previously declared
+shall not consider any scopes outside the innermost enclosing namespace.
+The other forms of `friend` declarations cannot declare a new member of
+the innermost enclosing namespace and thus follow the usual lookup
+rules.
 ``` cpp
+// Assume f and g have not yet been declared.
 void h(int);
 template <class T> void f2(T);
 namespace A {
   class X {
     friend void f(X);           // A::f(X) is a friend
 *using-declaration* does not declare its enumerators in the
 *using-declaration*’s declarative region. If a *using-declaration* names
 a constructor ([[class.qual]]), it implicitly declares a set of
 constructors in the class in which the *using-declaration* appears (
 [[class.inhctor]]); otherwise the name specified in a
+*using-declaration* is a synonym for a set of declarations in another
+namespace or class.
 Every *using-declaration* is a *declaration* and a *member-declaration*
 and so can be used in a class definition.
 ``` cpp
   using B::i;
   using B::i;       // error: double member declaration
 };
 ```
+Members added to the namespace after the *using-declaration* are not
+considered when a use of the name is made. Thus, additional overloads
+added after the *using-declaration* are ignored, but default function
+arguments ([[dcl.fct.default]]), default template arguments (
+[[temp.param]]), and template specializations ([[temp.class.spec]],
+[[temp.expl.spec]]) are considered.
 ``` cpp
 namespace A {
   void f(int);
 }
   struct x x1;      // x1 has class type B::x
 }
 ```
 If a function declaration in namespace scope or block scope has the same
+name and the same parameter-type-list ([[dcl.fct]]) as a function
+introduced by a *using-declaration*, and the declarations do not declare
+the same function, the program is ill-formed. If a function template
+declaration in namespace scope has the same name, parameter-type-list,
+return type, and template parameter list as a function template
+introduced by a *using-declaration*, the program is ill-formed. Two
+*using-declaration*s may introduce functions with the same name and the
+same parameter-type-list. If, for a call to an unqualified function
+name, function overload resolution selects the functions introduced by
+such *using-declaration*s, the function call is ill-formed.
 ``` cpp
 namespace B {
   void f(int);
   void f(double);
 When a *using-declaration* brings names from a base class into a derived
 class scope, member functions and member function templates in the
 derived class override and/or hide member functions and member function
 templates with the same name, parameter-type-list ([[dcl.fct]]),
 cv-qualification, and *ref-qualifier* (if any) in a base class (rather
+than conflicting). For *using-declaration*s that name a constructor,
 see  [[class.inhctor]].
 ``` cpp
 struct B {
   virtual void f(int);
 namespaces were considered and the relationships among the namespaces
 implied by the *using-directive*s do not cause preference to be given to
 any of the declarations found by the search. An ambiguity exists if the
 best match finds two functions with the same signature, even if one is
 in a namespace reachable through *using-directive*s in the namespace of
+the other.[^7]
 ``` cpp
 namespace D {
   int d1;
   void f(char);

Diff to HTML by rtfpessoa