对令人蛋疼的C++指针、数组的研究

原创内容，转载请保留出处。 我承认C/C++里面的指针、数组相当令人蛋疼。为了不让以后蛋疼，所以最近就研究了一下这个蛋疼的问题。先列一个本文内容的表，也算是为more标签做点贡献：

（本文基于C++语言，C语言可能略有不同）
  • 指针的意义、定义及使用方法（水）
  • 数组的意义、定义及使用方法（水）
  • 使用负数下标访问数组（雷人）
  • 数组指针？指针数组？（吓人）

一.指针的意义、定义及使用方法

所谓指针，就是指向一个对象的变量，这个对象可以是内置类型、类类型甚至指针类型。 学习指针的最好方法是coding!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//定义：
//定义指针也很简单，只要在变量名之前加*就可以声明一个指针。一个指针变量所接受的值即是它指向的类型变量的地址，要得到这个地址可以用&操作符得到。
int ival1 = 123;
int *iptr1; //这样就定义了一个指针
iptr1 = &ival1; //这样就把iptr1指向了ival
//另外一种简洁点的方法：
int ival2 = 123, *iptr2 = &ival2;

//使用：
//指针变量保存的是变量的地址，要使用指针指向的变量，就需要对指针进行解引用。解引用使用操作符*：
std::cout << "the value of ival2   :" << ival2 << std::endl
    << "the address of ival2 :" << iptr2 << std::endl
    << "the value of *iptr2  :" << *iptr2 << std::endl
    << "the address of iptr2 :" << &iptr2 << std::endl
    << "is iptr2 == &ival2   ?" << (iptr2 == &ival2) << std::endl << std::endl;

//我们还可以使用指向指针的指针……
int **pptr = &iptr2, ***ppptr = &pptr;
std::cout << "   ppptr:" << ppptr << std::endl
    << "  *ppptr:" << *ppptr << std::endl
    << " **ppptr:" << **ppptr << std::endl
    << "***ppptr:" << ***ppptr << std::endl;

运行的结果如下：

1
2
3
4
5
6
7
8
9
10

the value of ival2   :123
the address of ival2 :0x7fff405d4ab8
the value of *iptr2  :123
the address of iptr2 :0x7fff405d4aa0
is iptr2 == &ival2   ?1

   ppptr:0x7fff405d4a98
  *ppptr:0x7fff405d4aa0
 **ppptr:0x7fff405d4ab8
***ppptr:123

二.数组的意义、定义及使用方法

对于C++程序员，相比C程序员，可能就比较不喜欢数组了。因为数组的长度固定，需要自己管理，容易溢出……C++ STL提供了vector容器，安全性大大提高，但效率并不比数组差多少，因此C++程序员更喜欢vector。但也不得不说，合格的程序员是能够自己控制好程序的，溢出是可以避免的，长度也可以预设或者动态分配，况且还有那么些情况不能使用vector（比方说NOIP），那么数组就是唯一选择了。

所谓数组，就是一列类型相同的变量，它们在内存的分配上是连续的。定义数组就是在变量名后加[size]，size为数组大小，必须为常量、正整数。

1
2
3
4
5
6

int iarr[10];//iarr实际上是一个指针，指向数组第一个元素
for (size_t i = 0; i != 10; ++i)
  iarr[i] = i;
cout << " iarr   :" << iarr << endl
     << "*iarr   :" << *iarr << endl
     << "iarr[0] :" << iarr[0] << endl;

注意，C/C++的数组下标从0开始，一直到n-1（n为数组元素个数）。 输出如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

address of each item:
&iarr[0] = 0x7fff88eb0b60
&iarr[1] = 0x7fff88eb0b64
&iarr[2] = 0x7fff88eb0b68
&iarr[3] = 0x7fff88eb0b6c
&iarr[4] = 0x7fff88eb0b70
&iarr[5] = 0x7fff88eb0b74
&iarr[6] = 0x7fff88eb0b78
&iarr[7] = 0x7fff88eb0b7c
&iarr[8] = 0x7fff88eb0b80
&iarr[9] = 0x7fff88eb0b84
 iarr   :0x7fff88eb0b60
*iarr   :0
iarr[0] :0

三.使用负数下标访问数组

C/C++数组无法使用负数下标，这点让众多程序员很是头疼，尤其是OIer！！过去的方法基本上是在使用下标时加上一个偏移量。效率不说，万一某一个地方少加上偏移量了，那就慢慢debug去吧……其实，只要明白了数组和指针的关系，负数下标都是浮云啊！

1
2
3
4

int iarr[3] = {0, 1, 2};
for (size_t i = 0; i != 3; ++i)
  cout << "iarr[" << i << "] = " << iarr[i]
       << "tt*(iarr + " << i << ") = " << *(iarr + i) << endl;
输出： 
1
2
3

iarr[0] = 0       *(iarr + 0) = 0
iarr[1] = 1       *(iarr + 1) = 1
iarr[2] = 2       *(iarr + 2) = 2
！！！也就是说a[n]与(a+n)是相同的！也就是说&a[n]等同于&(a+n)等同于(a+n)！！ 你是不是想到了什么？ 
1
2
3
4
5
6
7

int iarr[3] = {0, 1, 2};
for (size_t i = 0; i != 3; ++i)
  cout << "iarr[" << i << "] = " << iarr[i]
       << "tt*(iarr + " << i << ") = " << *(iarr + i) << endl;
int *a = iarr + 1; // equal to &iarr[1], but quite faster than it
for (int i = -1; i <= 1; ++i)
  cout << "a[" << i << "] = " << a[i] << endl;
输出： 
1
2
3
4
5
6

iarr[0] = 0       *(iarr + 0) = 0
iarr[1] = 1       *(iarr + 1) = 1
iarr[2] = 2       *(iarr + 2) = 2
a[-1] = 0
a[0] = 1
a[1] = 2
更简单一点，用一个宏搞定。 
1
2
3
4
5
6
7
8

#define ARRAY(TYPE, NAME, LEFT, RIGHT) TYPE __myarray_##NAME[(RIGHT-LEFT)+1]; TYPE *NAME = __myarray_##NAME - LEFT;
  ARRAY(unsigned int, a, -3, 2)
  for (int i = -3; i <= 2; ++i)
  {
      a[i] = i + 3;
      cout << "a[" << i << "] = " << a[i]
           << "tt__myarray_a[" << i << " + 3] = " << __myarray_a[i+3] << endl;
  }
这个宏用到了#define中的##，##用来把前后两个参数连接起来。 输出： 
1
2
3
4
5
6

a[-3] = 0      __myarray_a[-3 + 3] = 0
a[-2] = 1      __myarray_a[-2 + 3] = 1
a[-1] = 2      __myarray_a[-1 + 3] = 2
a[0] = 3      __myarray_a[0 + 3] = 3
a[1] = 4      __myarray_a[1 + 3] = 4
a[2] = 5      __myarray_a[2 + 3] = 5

4.数组指针？指针数组？

我们知道sizeof 一个数组，回返回整个数组占用的空间大小；而sizeof 一个指针，回返回指针变量的大小。看看下面的程序，猜猜如何输出： 
1
2
3
4
5
6
7
8
9
10
11

int (*iarr1)[10];
cout << "sizeof iarr1  :" << sizeof iarr1 << endl;
cout << "sizeof *iarr1 :" << sizeof *iarr1 << endl << endl;

int *(iarr2[10]);
cout << "sizeof iarr2  :" << sizeof iarr2 << endl;
cout << "sizeof *iarr2 :" << sizeof *iarr2 << endl << endl;

int *iarr3[10];
cout << "sizeof iarr3  :" << sizeof iarr3 << endl;
cout << "sizeof *iarr3 :" << sizeof *iarr3 << endl << endl;
输出： 
1
2
3
4
5
6
7
8

sizeof iarr1  :8
sizeof *iarr1 :80

sizeof iarr2  :80
sizeof *iarr2 :8

sizeof iarr3  :80
sizeof *iarr3 :8

够雷人的吧？下面来细细分析一下： int (iarr1)[10];定义了一个数组指针。所谓数组指针，就是一个指向数组的指针。因此iarr1占用空间为8。iarr1指向一个10个元素的数组，所以iarr1占用空间为80。 int (iarr2[10]);定义了一个指针数组。所谓指针数组，就是一个数组元素为指针类型的数组。iarr2中保存了10个指针，因此iarr2占用空间为80。iarr2是一个指针，因此占用空间为8。 int iarr3[10];等同于int (iarr3)[10];，这是由于操作符的右结合性以及优先级高于[]操作符。

The End.本文写的并不是很好，草草地掠过了以上四个知识点。至于详细的，还是实践出真知，大家不妨多加尝试。

Comments