C++程序员应了解的那些事（75）using关键字~using声明，using指示，using代替typedef

目录

【using关键字】

【using声明】

【using指示】

【using代替typedef】

【using 让父类同名函数在子类中以重载方式使用】

【重载和using】

【函数匹配】

【重载和using声明】 

【重载和using指示】

【using关键字】

【using声明】

using声明的形式：
using namespace_name::name

        一个using声明一次只引入一个命名空间成员。

       using声明中引入的名字遵循常规作用域规则：从using声明点开始，直到包含该using声明的作用域的末尾，名字都是可见的。外部作用域中定义的同名实体被屏蔽。

注意using声明出现位置的影响，如下所示：

<示例1> -- 外部作用域中定义的同名实体被屏蔽 !
#include<iostream>
using namespace std;
namespace Lib
{
    void print(int x)
    {
        cout<<"int "<<x<<endl;
    }
}
void print(double y){
        cout<<"double "<<y<<endl;
}
int main()
{
    using Lib::print;//example 1 : main作用域中嵌套了Lib命名空间
    print(1.3);
    print(3);
    return 1;
}
//输出：
int 1
int 3

<示例2>
#include<iostream>
using namespace std;
namespace Lib
{
    void print(int x)
    {
        cout<<"int "<<x<<endl;
    }
}
void print(double y){
        cout<<"double "<<y<<endl;
}
using Lib::print;//example 2 : main作用域 平行于Lib命名空间
int main()
{
    print(1.3);
    print(3);
    return 1;
}
//输出：
double 1.3
int 3

<示例3>
#include<iostream>
using namespace std;
namespace Lib
{
    void print(int x)
    {
        cout<<"int "<<x<<endl;
    }
}
void print(double y){
        cout<<"double "<<y<<endl;
    }
int main()
{
    print(1.3);
    print(3);
    return 1;
}
//输出：
double1.3
double3

<示例4>
#include<iostream>
using namespace std;
namespace Lib
{
    void print(int x)
    {
        cout<<"int"<<x<<endl;
    }
}
int main()
{
   //  print(1.3);  error: 'print' was not declared in this scope
   //  print(3);    error: 'print' was not declared in this scope
    return 1;
}

<示例5>
#include<iostream>
using namespace std;
namespace   // 匿名 命名空间
{
    void print(int x)
    {
        cout<<"int"<<x<<endl;
    }
}
int main()
{
    print(1.3);
    print(3);
    return 1;
}
输出:
int1
int3

【using指示】

using指示的形式:
using namespace 命名空间名

        using指示同using声明一样，可以使我们能够使用命名空间的简写形式，简写名字从using指示点开始，直到出现using指示的作用域的末尾。但不同的是using声明可以选择性的部分可见，但using指示使得特定命名空间全部可见。

<示例代码>
namespace blip
{
    int bi = 10,bj = 20,bk = 30;
}
int bj = 0;
void main(){
    using namespace blip;
    ++bi;//right
    ++bj;//wrong , “bj”:不明确的符号  ×
    ++::bj;//right,bj=1;
    ++blip::bj;//right,bj=21;
    int bk = 97;
    ++bk;//right,bk=98
}

【using代替typedef】

   《深入理解c++11》中的描述如下：

<示例代码>
//using 取代typedef了,而且更加灵活  
#include<type_traits> 
#include<cstdio> 
#include <iostream>
#include <string>
#include <map>
#include <vector>

using myIntVec = std::vector<int>;  
void testUsing2()  
{  
    myIntVec mvec = { 1, 2, 3, 4, 5 };  
    mvec.push_back(123);  
    for (int num : mvec)  
        printf("--- num:%d\n", num);  
  
    std::cout << is_same < std::vector<int>, myIntVec>::value << std::endl; // 1  
}  

template <typename T>  
using MapStr = std::map<T, std::string>;  
void testUsing3()  
{  
    MapStr<int> intStrMap;  
    intStrMap.insert(make_pair(123, "aaa"));  
    intStrMap.insert(make_pair(456, "bbb"));  
  
    MapStr<std::string> strstrMap;  
    strstrMap.insert(make_pair("ccc", "ddd"));  
    strstrMap.insert(make_pair("eee", "fff"));  
} 

【using 让父类同名函数在子类中以重载方式使用】

<示例代码>
using namespace std;    
class Base  
{  
public:  
    void menfcn()  
    {  
        cout << "Base function" << endl;  
    }  
    void menfcn(int n)  
    {  
        cout << "Base function with int" << endl;  
    }  
//private:   
//  void menfcn(std::string _name) {}//会让基类using时报不可访问的错  
};    
class Derived : private Base  
{  
public:  
    using Base::menfcn;
    //using声明只能指定一个名字，不能带形参表，且基类的该函数不能有私有版本，否则编译报错! 
    //using父类方法，主要是用来实现可以在子类实例中调用到父类的重载版本  
    int menfcn(int num)  
    {  
        cout << "Derived function with int : "<< num << endl;  
        return num;  
    }  
};  
/* 
“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下： 
1、如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆） 
2、如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆） 
使用了using关键字，就可以避免1的情况，使得父类同名函数在子类中得以重载，不被隐藏 
*/  
void testUsing1()  
{  
    Base b;  
    Derived d;  
    b.menfcn();  
    d.menfcn();//如果去掉Derived类中的using声明，会出现错误：error C2660: 'Derived::menfcn' : function does not take 0 arguments      
    d.menfcn(123);  
    /* 
    Base function 
    Base function 
    Derived function with int : 123 
    */  
}  

【重载和using】

【函数匹配】

• 找到候选函数集，如果一个函数在调用时其声明可见并且与被调用函数同名，这个函数就是候选者；
• 从侯选集中选择可行函数。如果函数的形参数目与函数调用的实参数目相同，并且每个形参都可用对应实参匹配。这个函数就是可行的；
• 从可行集合中选择一个最佳匹配，并产生代码调用该函数。如果可行集合为空，则调用出错，没有匹配。如果可行集合非空且没有最佳匹配，则调用有二义性。

【重载和using声明】 

    无法通过using声明来引用特定函数声明！ 如：using namespace::functionName;

using NS::print(int);//wrong,connot specify parameter list
using NS::print();   //wrong

using NS::print;//ok,using declarations specify names only，无论参数列表如何都是写成这样

       如果命名空间内部的函数是重载的，那么该函数名字的using声明声明了所有具有该名字的函数。如果命名空间NS中有用于int和double的print函数，则NS::print的using声明使得两个函数都在当前作用域中可见。

       如果using声明在已经有同名且带相同形参表的函数的作用域中引入函数，则using声明出错,如示例1，否则，using声明定义给定名字的另一重载实例，效果是增大候选函数集合，如示例2。

<示例1>
#include<iostream>
using namespace std;
namespace Lib
{
    void print(int x)
    {
        cout<<"int "<<x<<endl;
    }
}
bool print(int y){ 
    cout<<"double "<<y<<endl;
    return true;
}
using Lib::print; //error: 'void Lib::print(int)' conflicts with a previous declaration
int main()
{
    print(1);//error C2668: “Lib::print”: 对重载函数的调用不明确,可能是void Lib::print(int)或bool print(int)
    return 1;
}

<示例2>
#include<iostream>
using namespace std;
namespace Lib
{
    void print(int x)
    {
        cout<<"int "<<x<<endl;
    }
}
void print(double y){
        cout<<"double "<<y<<endl;
}
using Lib::print;
int main()
{
    print(1.3);
    print(3);
    return 1;
}
输出：
double 1.3
int 3

【重载和using指示】

        using指示将命名空间成员提升到外围作用域。如果命名空间函数和命名空间所在的作用域中声明的函数同名，就将命名空间成员加到重载集合中：

<示例代码>
namespace AW{
int print(int);
}
namespace Primer{
double print(double);
}
using namespace AW;
using namespace Primer;
long double print(long double);
void main()
{
    print(1);//call AW::print(int)
    print(3.4);//call Primer::print(double)
}

       全局作用域中print函数的重载集合包含函数print(int)； print(double) ； print(long double)，即使这些函数原来在不同的命名空间中声明，它们都是为main中函数调用考虑的重载集合的组成部分。