目录
一 、#define
1. 含义
2. 用处
1. 条件编译
2. 解宏
3. 文件包含
二 typedef
1. 含义
2. 用处
1. 数据类型别名
2. 指针别名
3. 结构体别名
4. 与平台无关的数据类型
三 using
1. 含义
2. 用处
1. 权限管理
2.类型重命名
3. 继承体系中，改变部分接口函数的继承权限
四 #define和typedef的区别
#define主要用来做宏定义，主要格式为：
#define 标识符 常量
宏定义后的标识符就是代表常量的意思，再以后的代码当中，使用标识符的地方都被替换成常量了，这里的常量可以是字符、字符串、变量、类型、表达式等等。值得注意的是，宏定义定义的标识符是在程序编译之前的预处理阶段进行替换的，也就是说在预处理阶段，已经把程序中所有的标识符全部替换成了常量，因此在程序运行阶段是调试不了该标识符的。
所谓条件编译就是宏开关，当多个厂家找你开发一套程序，而这一套程序的逻辑恰好一样的，只是有些地方需要有不同的显示，你会选择统是开发多个项目吗，这是一个很蠢的做法，因为这几套程序的代码90%是相同的，你同时维护这么多套程序会很占用你的内存资源的，所以这个时候宏开关（条件编译）就起到了很好的作用，它相当于在你的程序开头定义一个宏变量，然后在你需要转换不同厂家不同逻辑代码的地方进行判断就可以了。
#include<iostream>
using namespace std;
# define GOOGLE 0
# define FACEBOOK 1
void main(){
string result = "0";
#ifdef GOOGLE
result = "I am a google company!";
#endif
#if FACEBOOK
result = "I am a facebook company!";
#endif
cout<<result;
}当GOOGLE = 0时，打印的结果是GOOGLE：
当FACEBOOK = 0时，打印的结果是FACEBOOK：
#define宏定义的变量的作用域是整个程序，当然，你也可以通过#undef来解宏，就是在解宏后，解宏后面代码中的这个宏定义标识符就失效了。
#include<iostream>
using namespace std;
# define GOOGLE 0
# define FACEBOOK 1
void main(){
#ifdef GOOGLE
result = "I am a google company!";
#endif
#if FACEBOOK
result = "I am a facebook company!";
#endif
#undef FACEBOOK // 解宏
#ifdef FACEBOOK // 失效
result = "I am a facebook company!";
#endif
cout<<result;
}我们可以看一下在解宏FACEBOOK后编译器的界面显示，QT界面上显示了解宏后再去判断宏的话是没有起到效果的：
宏定义还可以避免我们在开发程序时头文件相互引用，这样做的好处就是减少编译器的工作量
#ifndef _HEADFILE_
#define _HEADFILE_
...
#endif先判断有没有包含头文件_HEADFILE_，如果没有的话就引入，例如在Test.h文件中
#ifndef TEST_H
#define TEST_H
...
#endif // TEST_H
用typedef来给类型起一个别名，主要格式为：
typedef 类型 别名类型可以是基本数据类型，也可以是结构体等等。
定义了一个类型符号INT_32，用来表示int数据类型，在接下来的变量定义中可以使用该别名INT_32进行操作；
typedef int INT_32;
INT_32 A = 9;
定义了一个类型符号PCHAR，表示char指针，用PCHAR来定义Serven_3和Serven_4就可以让Serven_3 和 Serven_4成为char类型指针。
typedef char* PCHAR;
char Serven_1 = 's';
char Serven_2[] = "123456";
PCHAR Serven_3, Serven_4;
Serven_3 = &Serven_1; // 指向Serven_1
Serven_4 = &Serven_2; // 指向Serven_2
值得注意的是 PCHAR Serven_3, Serven_4 等价于 char *Serven_3, *Serven_4 ，它跟 char *Serven_3, Serven_4 不一样，前者是两个char类型的指针，后者是一个char类型指针，一个char类型变量。
在Serven_3前面加上const，会变成一个指针常量，指向的变量地址不能修改，但可以通过执政去修改变量的值。
const PCHAR Serven_5;以往定义一个结构体如下所示
struct Student{
int StuNo;
char StuName[20];
};如果我们需要实例化结构体对象，那么操作是：
struct Student Ser_stu; // 实例化一个结构体变量现在我们可以通过typedef来给结构体一个别名
typedef struct Student{
int StuNo;
char StuName[20];
}Stu;这下我们来实例化结构体对象的操作可以为：
Stu Ser_stu; // 实例化一个结构体变量在日常开发中，特别是在嵌入式单片机的开发中，我们可以通过定义一些平台没有提供的数据类型，例如：
typedef unsigned char BYTE; // 别名一个BYTE类型
typedef unsigned int UINT_32; // 别名一个32长度的整型类型using的作用是给数据类型起别名，它的作用跟typedef相似，主要格式为：
using 别名 = 类型等配合命名空间，对命名空间权限进行管理
using namespace std; // 释放整个命名空间到当前作用域
using::string; // 释放某个变量当前作用域
我相信你在刚开始接触C/C++语言的时候都会遇到过下面的代码，即没有加上命名空间权限using namespace std; 这会导致main函数中string是无法标识的，解决方案有两个，要么加上整个命名空间权限，要么在string前面加上std::。
#include<iostream>
void main(){
string serven;
}给string类型起一个别名，这样的格式看起来比typedef更加直观吧。
using Dstring = std::string;可以给一个很长的类名起一个别名：
using ILV = I_LOVE_YOU;当我们在面向对象编程的时候，往往会继承别的类，继承有三种方式，分别是公有继承（public）、私有继承（private）、保护继承（protected）。在这三种继承中，私有继承后，父类的所有成员属性和方法都成为了派生类的私有成员，这会导致派生类实例化的对象是不能访问这些成员属性和方法的，在这个时候，using就起到作用了，使用using就可以将其变成公有成员。
class Parents{
Parents(){}
~Parents(){}
public:
int serven1;
public:
int Speak(){
cout<<"I am taking!";
}
};
class Child(): private Parents{
public:
using Parents::Speak();
}
void main(){
Child Serven2 = new Child();
Serven2.Speak(); // 可以调用，因为使用了using，并且在子类中的public
Serven2.serven1; // 不能调用，因为是私有属性
}我们只看它们的第一个无别，typedef的别名前面加上const后表示定义的变量为指针常量，而define定义的表示常量指针。
#include<iostream>
using namespace std;
typedef int* PINT;
#define pint int*
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
const PINT serv1; // 相当于指针常量
PINT serv1;
const pint serv2; // 相当于常量指针
int s = 7;
int d = 3;
serv1 = &s;
serv2 = &s;
cout<<*serv1<<endl;
cout<<*serv2<<endl;
serv1 = &d; // 出错，因为指针常量不能指向别的变量地址了
serv2 = &d;
cout<<*serv1<<endl;
cout<<*serv2<<endl;
*serv1 = 6;
//*serv2 = 6; // 出错，因为常量指针不能修改变量的值
cout<<*serv1<<endl;
cout<<*serv2<<endl;
PINT SERVEN1, SERVEN2; // 表示SERVRN1和SERVEN2两个都是指针变量
SERVEN1 = &d;
SERVEN2 = &d;
pint SERVEN3, SERVEN4; // 只是做简单的替换，SERVEN3是指针变量，SERVEN4是int变量
SERVEN3 = &d;
SERVEN4 = 9;
cout<<*SERVEN1<<endl;
cout<<*SERVEN2<<endl;
cout<<*SERVEN3<<endl;
cout<<SERVEN4<<endl;
return a.exec();
}运行结果：
另外一个区别就是：
1. typedef是一个语句，后面要加上分号
2. #define是一个关键字，只是在做标识符的替换
3. typedef是在运行期间进行的，#define是在预编译期间进行的。
4. typedef在语法上是一个存储类的关键字（如auto、extern、mutable、static、register等一样），虽然它并不真正影响对象的存储特性，如：
typedef static int INT2; //不可行
编译将失败，会提示“指定了一个以上的存储类”。
5. 在有指针的情况下，typedef会好一些，因为下面代码中，PCHARdef仅仅是做字符串的替换，所以SERVEN3是一个指针，而SERVEN4是一个char类型的变量。PCHARtyp定义的两个SERVEN1和SERVEN2都是插入指针。
typedef char* PCHARtyp;
#define PCHARdef char*
PCHARtyp SERVEN1, SERVEN2;
PCHARdef SERVEN3, SERVEN4;喜欢就给小编点个赞吧，欢迎关注微信公众号 “三贝勒文子”