c++中别名的定义 using、#define、typedef、typename、namespace的使用

typedef typename #define namespace using区别

• 1.关键字typedef定义别名
• 2.typename
• 3.文本替换宏define
• 4.using
• 5.namespace 使用在命名空间上

1.关键字typedef定义别名

//例1：定义变量别名
typedef unsigned int  size_t; //size_t是unsigned int的别名
size_t i=2; //等价于 unsigned int i=2;
//例2:定义结构别名
typedef struct SA
{

}Sa,*Spa; //C结构写法，SA结构的一个指针对象别名Spa，和一个对象别名Sa
Sa s;
Spa* sp;
           

2.typename

1. 用于模板声明

template<typename T>
class S{};
           

1. 用于模板类嵌套从属命名时，强调这是一个类型

//例1：
template<typename C>
void f(const C& container, typename C::iterator iter);
//例2：
template<typename C>
class S
{
    typename C::iterator iter1;//声明一个 C::iterator 的成员 iter1
    using iter2=typename C::iterator; 定义别名 iter2 ，类型是C::iterator
};
           

3.文本替换宏define

#define PI 3.1415926 //用PI代替3.1415926
double db = PI; //db=3.1415926
           

4.using

1. 用于命名空间

//例1：
using namespace std;//命名空间std内的成员可以直接使用
cout <<"Hello World!";//true
int i;
cin >> i;//true
//例2：
using namespace std::cout;//可以直接使用命名空间std内的cout成员
cout <<"Hello World!";//true
int i;
cin >> i;//error
std::cin >> i;//true
           

1. 用于类成员
   1. 用于将基类成员引入到派生类的定义中，例如将基类的受保护成员暴露为派生类的公开成员
   2. 用于继承构造函数

struct B {
	B(){ std::cout << "B构造\n"; }
protected:
	void g(char) { std::cout << "B::g\n"; }
	int m; // B::m 为受保护
};

struct D : B {
	using B::m; // D::m 为公开
	using B::g; // D::g(char)变成公开
	void g(int) { std::cout << "D::g\n"; } // g(int) 与 g(char) 均作为 D 成员可见
	using B::B;//继承B的构造
};
int main(int argc, char* argv[])
{
	
	D d;// print: B构造 【d调用基类B的构造】
	d.m; //【类外可访问，m从基类的保护变公有】
	d.g(1); //print: D::g 
	d.g('c');//print: B::g
}

           

1. 用于类型别名与别名模板声明

template<typename T>
	using myVec=vector<T>;
	myVec<int> vec;
           

5.namespace 使用在命名空间上

语法:

• namespace 别名 = 命名空间名; (1)
• namespace 别名 = ::命名空间名; (2)
• namespace 别名 = 嵌套名::命名空间名; (3)

namespace Q {
	namespace V { // V 是 Q 的成员，且完全在 Q 内定义
  // namespace Q::V { // C++17 中对上述二行的替代写法
		class C { void m(); }; // C 是 V 的成员且完全定义于 V 内
							   // C::m 仅声明
		void f(); // f 是 V 的成员，但只在此声明
	}
	void V::f() // V 的成员 f 的 V 外定义
				// f 的外围命名空间仍是全局命名空间、Q 与 Q::V
	{
		extern void h(); // 这声明 ::Q::V::h
	}
	void V::C::m() // V::C::m 的命名空间（及类）外定义
				   // 外围命名空间是全局命名空间、Q 与 Q::V
	{
	}
}

int main(int argc, char* argv[])
{
	namespace nm1 = ::Q::V;
	namespace nm2 = Q::V;
	namespace nm3 = Q;
}
           

• 我的GitHub
• 我的CSDN
• 我的Gitee