C++ typedef 的详细用法

时间  2020-02-11 标签 c++ typedef 详细 用法

不太想谈#define，在题主的例子的这种用法里，它就是个文本替换工具，预处理器完成的，无脑替换，跟word里的replace如出一辙，不关编译器的事，我想谈一下 typedef。ios

搞懂了C++创始人写的< The design and evolution of CPP >中的下面这个例子，有助于你理解 typedef：程序员

typedef int P();
typedef int Q();

class X{	
	static P(); // 等价于 static int P();
	static Q();
}

这是一个极好的例子，先问一下 typedef int P() 到底作了什么？实际上是：web

declares a function type P as returning an int and taking no arguments.数组

  1. 官方定义

初次接触此类 typedef 用法的程序员直观上理解这个例子比较困难，咱们来看一下 typedef 的官方定义：svg

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 [some declaration] would define a type.函数

看我标黑的这句话，总结一下就是：任何声明变量的语句前加上 typedef 以后，原来是变量的都变成一种类型。无论这个声明中的标识符号出如今中间仍是最后。工具

  1. 隐藏技能

typedef 定义的新类型，使用时能够省略括号。this

什么意思？spa

typedeff int NUM;
NUM a = 10; // 也能够写成 NUM(a) = 10;
  1. 举例

先从初级的开始：指针

整型：

typedef int NUM;

结构体：

typedef struct(int a;) STRTCT;

指针：

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就是一个新定义的函数类型，它返回值为int类型，无参数。
根据个人第二点说明，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");
}

理解了上面这段再看下面这段：

理解复杂的定义和声明：

在阅读 Linux 的内核代码时，常常会遇到一些复杂的声明和定义，好比：

  • void * (* (*fp1) (int)) [10];
  • float (* (*fp2) (int, int, float)) (int);
  • typedef double (* (* (*fp3) ()) [10]) (); fp3 a;
  • int (* (*fp4()) [10]) ();

刚看到这些声明或定义时，一些初学者甚至有必定经验的工程师都有可能头皮发毛，大惑不解。若是缺少经验和方法来对这些内容进行理解，势必会让咱们浪费大量的时间。

我尝试对这些内容进行疏理和总结，为本身和有一样困惑的同窗答疑解惑。要理解这些复杂的声明和定义，我以为首先不能着急，应该由浅而深，逐步突破。下面先看一些简单的定义：

  1. 定义一个整型

    int a;

  2. 定义一个指向整形数的指针
    int *p;

  3. 定义一个指向指针的指针，它指向的指针指向一个整形数
    int **pp;

到这一步，我想大多数人都还好理解，咱们能够用一些简单的代码把这三条给串起来：

int a;
int *p;
int **pp;
p = &a; // p指向整数a所在的地址 
pp = &p; // pp指向指针p

  1. 定义一个包含10各整形数的数组

    int arr[10];

  2. 定义一个指向包含10个整形数数组的指针
    int (*pArr)[10];

用几行代码将四、5两个定义串起来：

int arr[10];
int (*pArr)[10];
pArr = &arr;

  1. 定义一个指向函数的指针，被指向的函数有一个整形参数，并返回整形值
    int (*pfunc)(int);

  2. 定义一个包含10个指针的数组，其中包含的指针指向函数，这些函数有一个整形参数并返回整形值
    int (* arr[10])(int);

用几行代码将六、7定义串起来：

int (*pfunc)(int);
int (*arr[10])(int);
arr[0] = pfunc;

到这一步，彷佛就不是那么好理解了。如今须要请出用于理解复杂定义的右左法则：

从变量名看起，先往右、再往左，碰到圆括号就调转阅读的方向；括号内分析完就跳出括号，仍是先右后左的顺序。如此循环，直到分析完整个定义。

让咱们用这个方法来分析上面的第6条定义：int (*pfunc)(int);

找到变量名 pfunc，先往右是圆括号，调转方向，左边是一个*号，这说明pfunc是一个指针；而后跳出这个圆括号，先看右边，又遇到圆括号，这说明(*pfunc)是一个函数，因此pfunc是一个指向这类函数的指针，即函数指针，这类函数具备一个int类型的参数，返回值类型是int。

接着分析第7条定义：int (*arr[10])(int);

找到变量名arr，先往右是[ ]运算符，说明arr是一个数组；再往左是一个*号，说明arr数组的元素是指针（注意：这里的*修饰的不是arr，而是arr[10]）。缘由是[ ]运算符的优先级比*要高，arr 先与[ ] 结合。）跳出圆括号，先往右又遇到圆括号，说明arr数组的元素是指向函数的指针，它指向的函数有一个int类型的参数，返回值类型是 int。

分析完这两个定义，相信多数人内心面应该有点谱了。可应该还有人会问：怎么判判定义的是函数指针（定义6），仍是数组指针（定义5），或是数组（定义7）？能够抽象出几个模式：

  • type (*var)(...); // 变量名var与*结合，被圆括号括起来，右边是参数列表。代表这是函数指针
  • type (*var)[]; //变量名var与*结合，被圆括号括起来，右边是[]运算符。表示这是数组指针
  • type (*var[])...; // 变量名var先与[]结合，说明这是一个数组（至于数组包含的是什么，由旁边的修饰决定）

至此，咱们应该有能力分析文章开始列出来了几条声明和定义：

  1. void * (* (*fp1) (int)) [10];

找到变量名fp1，往右看是圆括号，调转方向往左看到*号，说明fp1是一个指针；跳出内层圆括号，往右看是参数列表，说明fp1是一个函数指针，接着往左看是*号，说明指向的函数返回值是指针；再跳出外层圆括号，往右看是[ ]运算符，说明函数返回的是一个数组指针，往左看是void *，说明数组包含的类型是void *。简言之，fp1是一个指向函数的指针，该函数接受一个整型参数并返回一个指向含有10个void指针数组的指针。

  1. float (* (*fp2) (int, int, float)) (int);

找到变量名fp2，往右看是圆括号，调转方向往左看到*号，说明fp2是一个指针；跳出内层圆括号，往右看是参数列表，说明fp2是一个函数指针，接着往左看是*号，说明指向的函数返回值是指针；再跳出外层圆括号，往右看仍是参数列表，说明返回的指针是一个函数指针，该函数有一个int类型的参数，返回值类型是float。简言之，fp2是一个指向函数的指针，该函数接受三个参数(int, int和float)，且返回一个指向函数的指针，该函数接受一个整型参数并返回一个float。

  1. typedef double (* (* (*fp3) ()) [10]) (); fp3 a;

若是建立许多复杂的定义，可使用typedef。这一条显示typedef是如何缩短复杂的定义的。

跟前面同样，先找到变量名fp3（这里fp3实际上是新类型名），往右看是圆括号，调转方向往左是*，说明fp3是一个指针；跳出圆括号，往右看是空参数列表，说明fp3是一个函数指针，接着往左是*号，说明该函数的返回值是一个指针；跳出第二层圆括号，往右是[ ]运算符，说明函数的返回值是一个数组指针，接着往左是*号，说明数组中包含的是指针；跳出第三层圆括号，往右是参数列表，说明数组中包含的是函数指针，这些函数没有参数，返回值类型是double。简言之，fp3是一个指向函数的指针，该函数无参数，且返回一个含有10个指向函数指针的数组的指针，这些函数不接受参数且返回double值。

这二行接着说明：a是fp3类型中的一个。

  1. int (* (*fp4()) [10]) ();

这里fp4不是变量定义，而是一个函数声明。

找到变量名fp4，往右是一个无参参数列表，说明fp4是一个函数，接着往左是*号，说明函数返回值是一个指针；跳出里层圆括号，往右是[ ]运算符，说明fp4的函数返回值是一个指向数组的指针，往左是*号，说明数组中包含的元素是指针；跳出外层圆括号，往右是一个无参参数列表，说明数组中包含的元素是函数指针，这些函数没有参数，返回值的类型是int。简言之，fp4是一个返回指针的函数，该指针指向含有10个函数指针的数组，这些函数不接受参数且返回整型值。

用 typedef 简化复杂的声明与定义

以上咱们已经看到了很多复杂的声明和定义，这里再举一个例子：
int *(*a[10])(int, char*)

用前面的“右左法则”，咱们能够很快弄清楚：a是一个包含10个函数指针的数组，这些函数的参数列表是(int, char*)，返回值类型是int*。理解已经不成问题，这里的关键是若是要定义相同类型的变量b，都得重复书写：

int *(*b[10])(int, char*)

这里有没有方便的办法避免这样没有价值的重复？答案就是用typedef来简化复杂的声明和定义。

typedef能够给现有的类型起个别名。这里用typedef给以上a、b的类型起个别名：

typedef int *(*A[10]) (int, char*); // 在以前定义的前面加入typedef，而后将变量名a替换成类型名A
联系我们 沪ICP备13005482号-10