类作用域与命名空间续
(名字查找规则)
在版本4中，有关于类作用域中的名字查找有这么一段话：
迄今为止，在我们所编写的程序中，名字查找（寻找与给定的名字相匹配的声明的过程）是相对直接的。
(1) 首先，在使用该名字的块中查找名字声明，只需考虑在该项使用之前声明的名字。
(2) 如果找不到该名字，则在包围的作用域（外层作用域，也需要在使用之前）中查找。
(3) C++中所有名字必须在使用之前声明。
(4) 在名字查找期间，如果类作用域使用的名字不能确定为成员名，则在包含该类或者成员定义的作用域中查找，以便找到该名字声明。
知道理论不见得理解了本质，或者说理解可能会有偏差。下面我们一如既往地做个小测试，测试程序如下：
|
//findName 头文件 class client{
public:
client(){}
client(client& c){}
~client(){}
void CallShow()
{
void show();
show();
//Show(); 函数模板无法单独声明，而没有前项声
//明是不可以调用的
}
private:
int id;
};
template
class server{
public:
server(){}
server(server& s){}
~server(){}
void CallShow()
{
void show();
show();
//Show();
}
};
|
//findName.cpp
#include<iostream>
#include"findName"
using namespace std;
void show()
{
cout<<"Wellcome to call me!"<<endl;
}
template<class Ｔ>
void Show()
{
cout<<"0 == "<<static_cast(0)<<endl;
}
int main()
{
client cus;
cus.CallShow();
server hos;
hos.CallShow();
Show(); //注意无参模板函数调用
Show();
Show();
}
|
#include"findName"
很容易明白，就是把findName文件的内容直接拷贝放在当前位置，那么在一个文件中，我们很容易理解show，Show无法调用的缘故，我们不能在声明之前使用名字。
如果我们非得把程序调通，也不是没有办法，解决方案有两种方案：
方案一:
#include<iostream>
void show()
{
std::cout<<"Wellcome to callme!"<<std::endl;
}
template＜ｃｌａｓｓ Ｔ＞
void Show()
{
std::cout<<"0 =="<<static_cast(0)<<std::endl;
}
#include"findName"
using namespace std;
int main()
{
client cus;
cus.CallShow();
server hos;
hos.CallShow();
Show();
Show();
Show();
}
|
方案二：
#include<iostream>
void show();
template＜ｃｌａｓｓ Ｔ＞ //模板无前向声明方式
void Show()
{
std::cout<<"0 =="<<static_cast(0)<<std::endl;
}
#include"findName"
using namespace std;
void show()
{
std::cout<<"Wellcome to callme!"<<std::endl;
}
int main()
{
client cus;
cus.CallShow();
server hos;
hos.CallShow();
Show();
Show();
Show();
}
|
上述作用域风格其实是C++的全局作用域，我们可以使用C++的命名空间。
命名空间的名字查找规则:
(1) 类成员函数优先（按照子类--->基类顺序），一经找到停止。
(2) 若没有，在相应的命名空间中找（如usingnamespace std;就在std中查找）。
(3) 若还没有，就根据参数所在命名空间进行查找。
函数调用匹配原则：（自己理解的）
（1）首先匹配函数名，若能找到进行下一步匹配。
（2）接着匹配函数类型，若无法实现匹配（如参数是泛型），等实例化时再匹配。
（3）实例化时需要严格匹配。
也即一个模板可以在一个函数出现之前调用它，不过调用时的参数必须要有泛型参数，且实例化该模板时，被调函数必须在之前出现在相关命名空间。
我们先看一个简单的例子：
#include<iostream> #include<string>
template＜ｃｌａｓｓ Ｔ＞ void CallShow() { //Show(); //Show(std::string("empty")); } template＜ｃｌａｓｓ Ｔ＞ void CallShow(T s) { //show(); Show(s); //Show(std::string("empty")); } template＜ｃｌａｓｓ Ｔ＞ class display{ public: void CallShow(T s) { Show(s); } }; void Show() { std::cout<<"Empty Show!"<<std::endl; } void Show(std::string s) { std::cout<<"s = "<<s<<std::endl; } int main() { CallShow(); std::string str = std::string("song"); CallShow(str); display d; d.CallShow(str); } |
由此测试小程序，我们可以得出：
(1) Show(s)调用成功的原因，是由于模板函数的实例化时才算是定义
处，而实例化必须在调用时发生。且调用函数Show时，参数是泛
型参数，所以也须在调用时才能决定函数是否已经定义，而调用之前Show函数已经出现故调用成功。
(2) Show() 调用出错是因为，该处函数没有泛型参数。所以编译器可以直接作抉择，那么它会在在模板函数实例化之前匹配函数。此时Show()并没有定义，所以调用失败。
(3) Show(std::string("empty"))调用失败同(2)。
(4)注意一下CallShow()的调用方式。
当把下面代码置于namespace std中的话：
void Show()
{
std::cout<<"Empty Show!"<<std::endl;
}
void Show(std::string s)
{
std::cout<<"s = "<<s<<std::endl;
}
|
namespace std{
void Show()
{
std::cout<<"Empty Show!"<<std::endl;
}
void Show(std::string s)
{
std::cout<<"s = "<<s<<std::endl;
}
}
|
调用仍然成功，这个不太符合我们的理解，因为在调用Show时，我们并没有在调用Show时注明名字域std::Show,这貌似不合理。其实这是名字查找的第三条规则：根据参数的命名空间进行查找。
在mian函数中写两条语句：
Show();
Show(std::string("test"));
不出所料，第一句编译错误：找不到函数名。第二句执行成功。
当把std 改为stdl时，两句话都编译不通过。
当上述Show不置于namespace std中，而CallShow,display置于namespace std中时。
namespace std{
template＜ｃｌａｓｓ Ｔ＞
void CallShow()
{
//Show();
//Show(std::string("empty"));
}
template＜ｃｌａｓｓ Ｔ＞
void CallShow(T s)
{
//show();
Show(s);
//Show(std::string("empty"));
}
template＜ｃｌａｓｓ Ｔ＞
class display{
public:
void CallShow(T s)
{
Show(s);
}
};
}
|
编译不通过，错误很明显使用CallShow,display时必须加上作用域限定std::。
如果都加上namespace std那么执行也会完全通过。
如果代码改为如下：
#include<iostream> #include<string> namespace std{
void Show(int i){}
template＜ｃｌａｓｓ Ｔ＞
void CallShow()
{
//Show();
//Show(std::string("empty"));
}
template＜ｃｌａｓｓ Ｔ＞
void CallShow(T s)
{
//show();
Show(s);
//Show(std::string("empty"));
}
template＜ｃｌａｓｓ Ｔ＞
class display{
public:
void CallShow(T s)
{
Show(s);
}
};
}
namespace std{
void Show()
{
std::cout<<"Empty Show!"<<std::endl;
}
void Show(std::string s)
{
std::cout<<"s = "<<s<<std::endl;
}
}
int main()
{
std::CallShow();
std::string str = std::string("song");
std::CallShow(str);
std::display d;
d.CallShow(str);
//Show();
Show(std::string("test"));
}
|
程序能实现正常功能。
但是如果把，下面Show的namespace std去掉的话，那么就会出现编译错误。此时CallShow里只会匹配std中的那个Show，这是C++匹配规则。当在该命名空间中找到了就不会去外层作用域中查找。且不同命名空间之间不会发生重载机制。
本例中，Std中的Show不会与全局的Show形成重载，且当在std中找到Show之后就不会向外层查找（这其实是c语言中的名字屏蔽原则，局部屏蔽全局，可以用“::”显示调用）。然后发现参数不匹配所以出错。
但此处使用“::”不可以，原因不明。
如果去掉std中的Show定义就可以找到全局空间的Show正常运行。
一个小结论：命名空间可以直接使用全局空间中的名字，反之不可（必需用类似std::）。
我们再次改变代码：
|
#include<iostream> #include<string> namespace std{
void Show(int i){}
template＜ｃｌａｓｓ Ｔ＞
void CallShow()
{
//Show();
//Show(std::string("empty"));
}
template＜ｃｌａｓｓ Ｔ＞
void CallShow(T s)
{
//show();
Show(s);
//Show(std::string("empty"));
}
template＜ｃｌａｓｓ Ｔ＞
class display{
public:
void CallShow(T s)
{
Show(s);
}
};
}
int main()
{
std::CallShow();
std::string str = std::string("song");
std::CallShow(str);
std::display d;
d.CallShow(str);
}
namespace std{
void Show()
{
std::cout<<"Empty Show!"<<std::endl;
}
void Show(std::string s)
{
std::cout<<"s = "<<s<<std::endl;
}
}
|
这段代码能成功执行煞是费解，难道此处Show不是在实例化之后定义的吗？这个问题留待以后学完模板吧。
