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