区别

最本质的区别
#define 是在预编译期间执行的
using、typedef是在编译期间
因为define是在预编译期间进行替换的，所以没有类型检查，即使写错也不会发现，后两个在编译期间，
所以编译器可以进行类型检查的，容易维护，发现错误。

使用

一：define

#define 使用的坑有很多，这里就不细说了，有时间我会更新这个的，下面主要谈谈typedef

二：typedef

先看一个例子：
typedef int P();
typedef int Q();
class X {
    static P(Q); // 等价于`static int Q()`, Q在此作用域中不再是一个类型
    static Q(P); // 等价于`static int Q(int ())`, 定义了一个名为Q的function
};

这是一个极好的例子, 先问一下 typedef int P()到底做了什么? 其实是:
declares a function type P as returning an int and taking no arguments.

1. 官方定义初次接触此类typedef用法的程序员直观上理解这个例子比较困难, 我们来看一下typedef的官方定义:
Typedef does not work like typedef [type] [new name].
 The [new name] part does not always come at the end.
You should look at it this way: if [some declaration] declares a variable, typedef [same declaration] would define a type.
 总结一下就是: 任何声明变量的语句前面加上typedef之后，原来是变量的都变成一种类型。
不管这个声明中的标识符号出现在中间还是最后.

2. 隐藏技能typedef 定义的新类型, 使用时可以省略括号.什么意思?typedef int NUM;
NUM a = 10; // 也可写成`NUM(a) = 10;`
NUM(b) = 12; // 也可写成`NUM b = 12;`

3. 举例先从初级的开始:整形typedef int x; // 定义了一个名为x的int类型
结构体typedef struct { char c; } s; // 定义名为s的struct类型
指针typedef int *p; //定义了一个名为p的指针类型, 它指向int (中文描述指针好累)
接下来是高级的(注意标识符不一定在最后):数组typedef int A[];  // 定义一个名为A的ints数组的类型
函数typedef int f(); // 定义一个名为f, 参数为空, 返回值为int的函数类型
typedef int g(int); // 定义一个名为g, 含一个int参数, 返回值为int行的函数类型
现在回过头看:
typedef int P();
static P(Q); 
应该就比较好理解了,  P是一个新定义的function类型, 它返回值为int, 无参数根据我的第2点说明, P(Q);
 实际上等价于P Q, 声明Q是一个返回值为int, 无参数的函数.这玩意有什么用呢?
我们都知道C++语言里, 函数都是先声明后使用的(除非在使用之前定义), 看以下例子:

#include <iostream>
#include <stdio.h>
#include <string>

typedef int P(); // 简单的
typedef void Q(int *p, const std::string& s1, const std::string& s2, size_t size, bool is_true); // 复杂的
class X {
public:
    P(eat_shit); // 等价于声明`int eat_shit();`
    Q(bullshit); // 等价于声明`void bullshit(int *p, const string& s1, const string& s2, size_t size, bool is_true);`
};

int main() {
    X *xx;
    printf("shit ret: %d\n", xx->eat_shit());
    int a[] = {1, 3, 4, 5, 7};
    xx->bullshit(a, "foo", "bar", sizeof(a)/sizeof(int), true);
}

int X::eat_shit() {
    return 888;
}

void X::bullshit(int *p, const std::string& s1, const std::string& s2, size_t size, bool is_true) {
    std::cout << "s1: " << s1 << ", s2: " << s2 << ", size: " << size << std::endl;
    printf("elems:\n");
    for(int i = 0; i < size; i++) {
        printf("%d %s",  *p++, (i == size-1) ? "" : ",");
    }
    printf("\n");
}

链接：https://www.zhihu.com/question/29798061/answer/144423125

三：using

using 和typedef类似，主要区别如下

• 定义一般类型的别名没区别。
• 定义模板的别名，只能使用using。
  具体的介绍如下:

模板的别名是什么呢？
在进入这个主题之前，各位应该先弄清楚「模板」和「类型」本质上的不同。
class template (类别模板，是模板)是用来产生template class（模板类别，是类型）。
在C++03中，typedef可定义模板类别为一个新的类型名称，但是不能够使用typedef来定义模板的别名。举例来说：

template <  typename  first ,  typename  second ,  int  third > 
class  SomeType ;

template <  typename  second > 
typedef  SomeType < OtherType ,  second ,  5 >  TypedefName ;  //在C++03是不合法的
这不能够通过编译。

为了定义模板的别名，C++11将会增加以下的语法：

template <  typename  first ,  typename  second ,  int  third > 
class  SomeType ;

template <  typename  second > 
using  TypedefName  =  SomeType < OtherType ,  second ,  5 > ;

using也能在C++11中定义一般类型的别名，等同typedef：

typedef  void  ( * PFD )( double );         //传统语法
using  PFD  =  void  ( * )( double );       //新增语法

补充：
using namespace 是命名空间的引用可以把它当做就是去除命名空间的，通常我们引入<thread>
的时候我们使用thread，通常会用std::thread但是加上using namespace std;之后我们就可以直接用thread了，当然如果其他命名空间也有一样的thread比如boost，我们使用了using namespace boost，当我们使用thread， 编译器就会报错了，所以尽量少用命名空间的引用。

#include <boost/thread.hpp>
#include <thread>
using namespace std;
using namespace boost;
thread(...); // error
std::thread() //正确
boost::thread()//正确