C++ 学习 typedef和指针的一些使用思想。简单易懂

本文搬自大佬的原文

最原始的文章是B乎上的一个大佬给的。

-------------------------正文-----------------------------

搞懂了c++创始人写的$<thedesignandevolutionofcpp>$中的下面这个例子, 有助于你理解typedef

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

这是一个极好的例子, 先问一下 typedef int P()到底做了什么? 其实是:
将函数类型P声明为返回int且不接受参数
英文原文是：
declares a function type P as returning an int and taking no arguments.

官方定义

初次接触此类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之后，原来是变量的都变成一种类型。不管这个声明中的标识符号出现在中间还是最后.

隐藏技能

typedef 定义的新类型, 使用时可以省略括号.什么意思?

typedef int NUM;
NUM a = 10; //也可以写成NUM(a) = 10;

举例

先从初级的开始:

整形 int

typedef int NUM;

结构体 struct

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是一个新定义的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");
}

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

理解复杂的定义和声明：

在阅读Linux的内核代码是经常会遇到一些复杂的声明和定义，例如：

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

    (2)  float (* (*fp2) (int, int, float)) (int);

    (3)  typedef double (* (* (*fp3) ()) [10]) ();

           fp3 a;

    (4)  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

4. 定义一个包含10个整型变量的数组

 int arr[10];

5. 定义一个指向包含10个整型变量数组的指针

int (*pArr) [10];

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

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

6. 定义一个指向函数的指针，被指向的函数有一个整型参数并返回整型值

 int (*pfunc) (int);

7. 定义一个包含10个指针的数组，其中包含的指针指向函数，这些函数有一个整型参数并返回整型值

int (*arr[10]) (int);

用几行代码将6、7两个定义串起来：

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

到这一步，似乎就不是那么好理解了。现在需要请出用于理解复杂定义的“右左法则”：
从变量名看起，先往右，再往左，碰到圆括号就调转阅读的方向；括号内分析完就跳出括号，还是先右后左的顺序。如此循环，直到分析完整个定义。

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

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

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

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

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

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

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

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

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

(2) float (* (*fp2) (int, int, float)) (int);

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

(3) typedef double (* (* (*fp3) ()) [10]) ();

fp3 a;

如果创建许多复杂的定义，可以使用typedef。这一条显示typedef是如何缩短复杂的定义的。
跟前面一样，先找到变量名fp3（这里fp3其实是新类型名），往右看是圆括号，调转方向往左是$\ast$，说明fp3是一个指针；跳出圆括号，往右看是空参数列表，说明fp3是一个函数指针，接着往左是$\ast$号，说明该函数的返回值是一个指针；跳出第二层圆括号，往右是[]运算符，说明函数的返回值是一个数组指针，接着往左是$\ast$号，说明数组中包含的是指针；跳出第三层圆括号，往右是参数列表，说明数组中包含的是函数指针，这些函数没有参数，返回值类型是double。简言之，fp3是一个指向函数的指针，该函数无参数，且返回一个含有10个指向函数指针的数组的指针，这些函数不接受参数且返回double值。
这二行接着说明：a是fp3类型中的一个。

(4) int (* (*fp4()) [10]) ();

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

找到变量名fp4，往右是一个无参参数列表，说明fp4是一个函数，接着往左是$\ast$号，说明函数返回值是一个指针；跳出里层圆括号，往右是[]运算符，说明fp4的函数返回值是一个指向数组的指针，往左是$\ast$号，说明数组中包含的元素是指针；跳出外层圆括号，往右是一个无参参数列表，说明数组中包含的元素是函数指针，这些函数没有参数，返回值的类型是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

为了简化代码和调用一些外部库而使用 typedef

结合一开始的那一大段代码。

当我们需要调用一些如PCL点云库等就需要使用typedef

例如

#include "kinect2_grabber.h"
#include <iostream>
#include <kinect.h>
#include <pcl\io\pcd_io.h>
#include <pcl/filters/conditional_removal.h>
#include <pcl/visualization/cloud_viewer.h> 
#include <pcl/visualization/pcl_visualizer.h>

using namespace std;

typedef pcl::PointXYZRGBA PointType;

int main()
{
	int c = 0;
	int total = 0;//文件名
	//pcl::PointCloud<PointType> cloud_filtered;// 按范围过滤后的点云

	boost::shared_ptr<pcl::visualization::PCLVisualizer> m_viewer;

	//显示窗口初始化
	m_viewer.reset(new pcl::visualization::PCLVisualizer("viewer", false));
	m_viewer->setBackgroundColor(0, 0, 0);//设置背景颜色
	m_viewer->initCameraParameters();
	//m_viewer->addCoordinateSystem();//添加红绿蓝坐标轴
	m_viewer->createInteractor();


	// 获取Kinect设备	
	// Point Cloud
	pcl::PointCloud<PointType>::ConstPtr pointCloud_XYZRGBA;  //指针变量

	//  检测到的点云回调函数
	boost::mutex mutex; //并发编程互斥锁
	boost::function<void(const pcl::PointCloud<PointType>::ConstPtr&)> function = [&pointCloud_XYZRGBA, &mutex](const pcl::PointCloud<PointType>::ConstPtr& ptr) { //只能用ConstPtr，不能用Ptr
		boost::mutex::scoped_lock lock(mutex);
		/* Point Cloud Processing */
		pointCloud_XYZRGBA = ptr->makeShared();
		//ptr->makeShared() = NULL;
	};

	boost::shared_ptr<pcl::Grabber> grabberForKinect = boost::shared_ptr<pcl::Grabber>(new pcl::Kinect2Grabber);// Kinect2Grabber
	boost::signals2::connection connection = grabberForKinect->registerCallback(function); // Register Callback Function
	grabberForKinect->start();  //Start Grabber

	while (!m_viewer->wasStopped()) {
		// Update Viewer

		c++;

		m_viewer->spinOnce(1); //调用交互程序并更新屏幕一次。
		boost::mutex::scoped_try_lock lock(mutex);

		//cloud_filtered = filterByScope(pointCloud_XYZRGBA, Z_nearby, Z_faraway, X_left, X_right, Y_bottom, Y_top);//截取对应范围图像

		if (lock.owns_lock() && pointCloud_XYZRGBA) {
			//cloud_filtered = filterByScope(pointCloud_XYZRGBA, Z_nearby, Z_faraway, X_left, X_right, Y_bottom, Y_top);
			//5 显示 Point Cloud
			if (!m_viewer->updatePointCloud(pointCloud_XYZRGBA->makeShared(), "cloud")) {//pointCloud_XYZRGBA是指针类型，不能用( . )运算符
				m_viewer->addPointCloud(pointCloud_XYZRGBA->makeShared(), "cloud");
			}
			if (c % 10 == 0) {//每隔一段时间保存一次图片
				//存储图片。
				char name[100];
				sprintf(name, "D:\\kinect_pointcloud\\%d.pcd", total++);
				pcl::io::savePCDFileASCII(name, *pointCloud_XYZRGBA);//以.pcd的格式保存点云数据到磁盘
			}
		}
	}//while


}