C++命名空间、using

目录

一，命名空间

1，namespace

2，std

3，作用域解析

4，命名空间嵌套

5，不同命名空间的函数区分

二，using

1，命名空间

2，类型命名

---

一，命名空间

1，namespace

命名空间namespace的作用是控制作用域，便于管理，也便于命名。

2，std

我感觉C++ prime plus书上这一段写的不全面，

using std::cout; 也可以放在函数定义之前，让文件中的所有函数都能使用cout这个元素。

3，作用域解析

双冒号 :: 可以用来解析命名空间，类也相当于一种命名空间，也是用双冒号解析。

#include<iostream>
using std::cout;

namespace A{
    int f(int x)
    {
        return x*x;
    }
}

int main()
{
    int x=5;
    cout<<A::f(x);
    return 0;
}

命名空间里面用外面的符号是可以直接用的：

int x = 5;
namespace A
{
	void f()
	{
		cout << x;
	}
}

int main()
{
	A::f();
	return 0;
}

4，命名空间嵌套

#include<iostream>
using std::cout;

namespace A{
    namespace B{
        int f(int x)
        {
            return x*x;
        }
    }
}

int main()
{
    int x=5;
    cout<<A::B::f(x);
    return 0;
}

5，不同命名空间的函数区分

这样是可以编译运行的：

int f(int a, int b)
{
	return 1;
}
namespace A
{
	void fun()
	{
		cout << f(1, 2);
	}
}

int main()
{
	A::fun();
	return 0;
}

这样会编译失败：

int f(int a, int b)
{
	return 1;
}
namespace A
{
	int f(double a) {
		return 2;
	}
	void fun()
	{
		cout << f(1, 2);
	}
}

int main()
{
	A::fun();
	return 0;
}

也就是说，不能这样重载，这样写只会发生覆盖。

实现跨命名空间的函数调用的正确写法：

namespace B {
	int f(int a, int b)
	{
		return 1;
	}
	namespace A
	{
		int f(double a) {
			return 2;
		}
		void fun()
		{
			cout << B::f(1, 2);
		}
	}
}

int main()
{
	B::A::fun();
	return 0;
}

或者：

int f(int a, int b)
{
	return 1;
}
namespace A
{
	int f(double a) {
		return 2;
	}
	void fun()
	{
		cout << ::f(1, 2);
	}
}

int main()
{
	A::fun();
	return 0;
}

二，using

 using有2种用法：命名空间、类型命名。

1，命名空间

（1）使用整个命名空间

如：using namespace std;

也可以自定义命名空间

（2）使用命名空间中的某个成员

如：using std::vector;

2，类型命名

（1）普通类型

    using d = double;
    d x = 1.23;

这个用法和typedef一样

    typedef double d;

（2）函数指针

    using pfunc=float (*)(float, float);
    pfunc f = pow;
    cout << f(2, 3);

这个用法和typedef一样

    typedef float (*pfunc)(float, float);

如果函数有重载，那么函数指针赋值时选择哪个重载，和直接调用时选择哪个重载的逻辑是类似的：

直接调用，按照入参类型选择重载，函数指针赋值，按照入参和出参类型选择重载。

（3）模板别名

无参别名：（包括有参的vector变成无参的vt这种情况）

    using vt=vector<int>;
    vt v;
    v.push_back(123);
    cout<<v[0];

这个用法和typedef一样

typedef vector<int> vt;

有参别名：

template <typename T>
using vt=vector<T>;

int main()
{
    vt<int> v;
    v.push_back(123);
    cout<<v[0];
    return 0;
}

注意，using给有参类型起别名，必须在函数外进行。

这个用法，typedef没有，只有using可用于定义带模板的类型。