C++ Primer 5th笔记（chap 18 大型程序工具） 类 命名空间与作用域

Posted 2021-12-04 thefist11

1. 命名空间内部名字的查找规则

由内向外依次查找每个外层作用域。

• 外层作用域也可能是一个或多个嵌套的命名空间， 直到最外层的全局命名空间查找过程终止。

• 只有位于开放的块中且在使用点之前声明的名字才被考虑

 namespace A {
        int i;
        namespace B {
            int i;        // hides A::i within B
            int j;
            int f1()
            {
                int j;    // j is local to f1 and hides A::B::j
                return i; // returns B::i
            }
        } // namespace B is closed and names in it are no longer visible
        int f2() {
           return j;     // error: j is not defined
        }
        int j = i;      // initialized from A::i
 }

1.1 命名空间中的类的查找规则

当成员函数使用某个名字时， 首先在该成员中进行查找， 然后在类中查找（ 包括基类）， 接着在外层作用域中查找，这时一个或几个外层作用域可能就是命名空间

namespace A {
        int i;
        int k;
        class C1 {
        public:
            C1(): i(0), j(0) { }   // ok: initializes C1::i and C1::j
            int f1()
            {
                 return k;        // returns A::k
            }
            int f2()
            {
                return h;        // error: h is not defined
            }
            int f3();
        private:
           int i;                // hides A::i within C1
           int j;
        };
        int h = i;               // initialized from A::i
}
// member f3 is defined outside class C1 and outside namespace A
int A::C1::f3()
{
    return h;               // ok: returns A::h
}

2. 实参相关的查找与类类型形参

隐藏规则：直接访问输出运算符。

当我们给函数传递一个类类型的对象时， 除了在常规的作用域查找外,还会查找实参类所属的命名空间。 这一例外对于传递类的引用或指针的调用同样有效

eg.

std::string s;
std::cin » s;

operator>> (std::cin, s);

或者使用函数调用的形式以把命名空间的信息包含进来:

std::operator»(std::cin, s) ; / / 正确： 显式地使用 std::>>

2.1 查找与 std::move 和 std::forward

如果在应用程序中定义了一个标准库中已有的名字， 则将出现以下两种情况中的一种：

• 根据一般的重载规则确定某次调用应该执行函数的哪个版本
• 应用程序根本就不会执行函数的标准库版本

2.2 友元声明与实参相关的查找

namespace A {
	class C {
		// 两个友元， 在友元声明之外没有其他的声明
		// 这些函数隐式地成为命名空间 A 的成员
		// 除非另有声明， 否则不会被找到
		friend void f(const C& ); // 才艮据实参相关的查找规贝可以被找到
		friend void f2();
	}
}

当类声明了一个友元时， 该友元声明并没有使得友元本身可见

一个另外的未声明的类或函数如果第一次出现在友元声明中， 则我们认为它是最近的外层命名空间的成员

int main ( )
{
	A::C cobj;
	f(cobj);
	f2();
	//正确： 通过在 A::C 中的友元声明找到 A::f
	//错误： A::f 2 没有被声明
}