[关闭]
@fuheimao 2019-06-23T14:25:32.000000Z 字数 2149 阅读 58

一起来玩指针黑魔法吧!

C++


很久没写博客了,那这次就写一篇稍微硬核一点的……写得有点杂乱×

数组与指针

  1. int arr[10];

当提到arr到底是什么的时候,一些人可能会说它是指向数组首元素的指针,即&arr[0]。但事实上,这种说法是不对的。

数组的类型就是数组。

也就是说,arr就是一个可以存放 10 个int的数组,其类型为int [10]

但是在某些情况下,数组名会隐式类型转换为指向数组首元素的指针,例如:

  1. std::cout << *(arr + 1);

上述代码中,arr即被转换为了int*,这句代码等价于:

  1. std::cout << arr[1];

反过来,[]运算符其实会展开成那样。说到这里,就不得不提一下,arr[1]还可以写作1[arr]。因为前者会展开成*(arr + 1),后者会展开成*(1 + arr),这两个当然是一样的。

数组退化为指针时,会产生一些问题,比如丢失长度信息。

  1. int sum(int* arr) {
  2. int length = sizeof(arr) / sizeof(int);
  3. int s = 0;
  4. for (int i = 0; i < length; ++i) {
  5. s += arr[i];
  6. }
  7. return s;
  8. }

上述函数的理想作用为对传入的arr数组进行求和,但由于传入参数时,数组退化为指针,已经丢失了长度信息,所以sizeof(arr)其实是一个int*所占的字节数。解决这个问题的方法有很多,例如再传入该数组的长度作为第二个参数。

既然arr是数组,那么&arr是什么呢?

&arrarr这个数组的指针,类型为int (*)[10]。当arr退化为指针时,其值与&arr的值相同,不过由于它们的类型不同,对它们进行运算得到的结果也不同。我们知道,对于指针进行加减运算,其实是以该指针基类型所占的字节数为单位进行移动的。如arr + 1,则移动了 4 字节。而&arr的基类型为 10 个元素的int数组,那么&arr + 1自然会移动 40 字节。

你可能注意到int (*)[10]中的*是加了括号的,而这个括号也是必要的。如果不加,int* [10]则变成了int* pointer[10]pointer的类型,即有 10 个int*元素的数组。

C++ 11引入了“序列 for 循环”,例如:

  1. for (auto i : arr) {
  2. std::cout << i << " ";
  3. }

这样做就可以遍历arr中的每个元素。

假设你有一个奇葩的需求,比如要从arr[1]开始遍历,而且想用序列 for 循环,那该怎么办呢?

一位同学写出了如下的代码(当然是不对的):

  1. for (auto i : arr + 1) {
  2. std::cout << i << " ";
  3. }

由于对arr进行了运算,它退化成了指针。而序列 for 循环依赖于std::begin()std::end(),这两个函数仅对数组和容器有效。

指针之间是可以相互转换的。

我们可以通过恰当的类型转换来完成上述任务。

  1. for (auto i : *(int (*)[9])(arr + 1)) {
  2. std::cout << i << " ";
  3. }

之前我们提到,数组首元素地址与数组地址值相同,现在我们需要从arr[1]开始遍历,那自然,从这里开始的数组有 9 个元素,数组地址与arr[1]地址相同,所以我们把arr + 1这个指针转换为数组指针,再解引用,即得到了这个数组,也就可以使用序列 for 循环语句了。

虚函数表

我们知道C++使用虚函数实现多态特性。对象中有一个虚函数表指针,而虚函数表中则存放了虚函数们的指针。有没有什么办法来验证呢?请看如下程序:

  1. #include <iostream>
  2. using namespace std;
  3. class Test {
  4. public:
  5. virtual void fun1() {
  6. cout << "fun1 is called" << endl;
  7. }
  8. virtual void fun2() {
  9. cout << "fun2 is called" << endl;
  10. }
  11. };
  12. typedef void (*func)();
  13. int main() {
  14. Test t;
  15. cout << &t << endl;
  16. cout << (int*)(&t) << endl;
  17. cout << (int*)*(int*)(&t) << endl;
  18. func f1 = (func)*((int*)*(int*)(&t) + 0);
  19. func f2 = (func)*((int*)*(int*)(&t) + 1);
  20. f1();
  21. f2();
  22. return 0;
  23. }

为简单起见,在测试类中只有两个无参无返回值的虚函数。而func为指向无参无返回值的函数的指针类型。

一般情况下,虚函数表指针位于对象最开始。我们假设该程序为 32 位程序,即所有地址占 4 字节。那么虚函数表指针就位于对象开始 4 字节。

(int*)(&t)即将该对象指针转换为int*,解引用后获得该对象开始 4 字节的数据,即虚函数表指针的值,再将该值转换为int*,则(int*)*(int*)(&t)就是虚函数表首元素的地址了。我们令int* p = (int*)*(int*)(&t),现在就可以把p看成一个装着虚函数地址的数组了。*(p + 0)就是该数组第一个元素,即第一个虚函数fun1的地址,再把它转换为func类型,到此,我们就可以成功调用fun1了!由于p数组是连续的,*(p + 1)则是第二个虚函数fun2的地址。

思考:如果是 64 位程序,会有什么不同呢?
(本文完,想到啥再补充×)

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注