指针后面紧跟下表运算符的解释！！[]运算符的本质

今天在复习Linux编程知识，看到了文件映射中的一个程序，其代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <string.h>
#include <sys/mman.h>
struct stu
{
	char name[20];
	int  age;
	float score;
};
main()
{
	int fd;
	struct stu *s;//文件在虚拟内存的映射首地址
	struct stat st;
	int size;//文件大小
	int count;//记录条数
	int i;
	//1.打开文件
	fd=open("newstu.dat",O_RDWR|O_CREAT|O_EXCL,0666);
	if(fd==-1)
	{
		fd=open("newstu.dat",O_RDWR);
		if(fd==-1) printf("::%m\n"),exit(-1);
	}
	//2.得到文件大小，文件记录条数
	fstat(fd,&st);
	size=st.st_size;
	count=size/sizeof(struct stu);
	//3.文件大小改变只要在munmap之前调用都有效	
	//ftruncate(fd,size+sizeof(struct stu));
	//4.映射到一个虚拟的地址
	s=mmap(0,size+sizeof(struct stu),
				PROT_READ|PROT_WRITE,
				MAP_SHARED,fd,0);
	//5.把数据写入虚拟地址
	/*
	printf("输入姓名:");
	scanf("%s",s[count].name);
	printf("输入年龄:");
	scanf("%d",&(s[count].age));
	printf("输入成绩:");
	scanf("%f",&(s[count].score));
	ftruncate(fd,size+sizeof(struct stu));
	*/
	for(i=0;i<count;i++)
	{
		printf("%s,\t,%d,\t%.2f\n",
			s[i].name,s[i].age,s[i].score);
	}	
	//6.卸载虚拟地址
	munmap(s,sizeof(struct stu)+size);
	//7.关闭文件
	close(fd);
}

其中有s[count].name   s[count].age     s[count].score  这里让我感到困惑，后来看到了前辈的解释，恍然大悟。看来对[]运算符的理解还没有到位。其实是非常简单的东西，竟让我感到异常的困惑，看来以前的书白看了，连最起码的东西都忘记了。。。。。。。。惭愧，特记录如下。

其实就是   a[10]=*(a+10)  而已啊。

本帖一下内容转子：http://blog.youkuaiyun.com/code_crash/article/details/4855000   感谢前辈对我的帮助

下标运算符[]一直被作为数组的专有运算符来介绍，经过长年的应用，人们也早已对这个用法习以为常，视为跟每天的午餐一样稀松平常的事情。当你很遐意地写下a[0]表达式的时候，如果抽空回过头来看看标准中关于下标运算符的条款，你很可能会大吃一惊：

 

6.5.2.1 Array subscripting

 

Constraints

One of the expressions shall have type ‘‘pointer to object type’’, the other expression shall have integer type, and the result has type ‘‘type’’.

 

其中一个表达式具有指针类型，而不是数组类型！为什么会这样呢？如果规定为数组类型，由于表达式中的数组类型会隐式转换为指针类型，两个条款就会产生矛盾，当然，可以将下标运算符也作为转换规则的例外，但直接规定为指针类型显然能带来更多的好处，而且，既然数组类型能够转换为指针类型，却不让指针使用下标运算符，会显得无可理喻。从条款的角度来讲，下标运算符其实是指针运算符。

  

    另一个表达式的类型是integer，这意味着表达式的值可以是负数，这是由于指针运算里包含了减法的缘故，但是要注意不应该发生越界的行为。

 

在条款的上下文中，并没有规定[]运算符两个操作数的顺序，这意味着即使调换两个操作数的位置，也没有违反标准。这现象还可以从另一个角度进行分析，在表达式中，D[N]会转换为等价表达式*( D + N )，把D和N的位置调换，就成了*( N + D )，就是N[D]了。

考虑如下代码：

 

int a[10]，*p = a;
p[0] = 10;
( p + 1 )[0] = 20;
0[p + 1] = 10;
( &a )[0][0] = 20;
0[&a][0] = 30;
0[0[&a]] = 40;
a[0] = “0123456789ABCDEF”[0];

下面对各个表达式进行解释：

p[0]：就是a[0]；

( p + 1 )[0]：p移动一个int的距离，就是a[1]；

0[p + 1]：就是( p + 1 )[0]；

( &a )[0][0]：这个表达式有点古怪，a的类型是int[10]，&a就是int( * )[10]，是一个指向具有10个int元素的一维数组的指针，( &a )[0]就是&a指向的第0个元素，类型为int[10]，因此( &a )[0][0]就是( &a )[0]的第0个元素。

0[&a][0]：把( &a )[0][0]第一维的0与&a调换一下，就是0[&a][0]；

0[0[&a]]：再调换0[&a]与第二维[0]中的0，就成了0[0[&a]]，跟( &a )[0][0]等价。

 

最后一个表达式”0123456789ABCDEF”[0]是一个常用的技巧，它可以快速将一个数字转换为16进制字符。”0123456789ABCDEF”是一个字符串字面量，类型是char[17]（在C中）或者const char[17]（在C++中），转换后的指针类型分别为char*和const char*，因此”0123456789ABCDEF”[0]就是第0个元素’0’。这个技巧常常用在进制转换中，以下代码将一个长整数的内存映像转换为16进制表示：

 

char* convert( unsigned long Value )
{
       static char Buffer[sizeof( unsigned long ) * 2 + 1];
       int i;
       for( i = sizeof( unsigned long ) * 2 - 1; i >= 0; --i )
       {
              Buffer[i] = "0123456789ABCDEF"[Value % 16];
              Value /= 16;
       }
       return Buffer;
}

 

当然，笔者在这里介绍这些古怪的表达式仅仅为了对下标运算符进行一些探讨，并非鼓励人们编写这样的代码。但在某些情况下，形如"0123456789ABCDEF"[Value%16]这样的表达式仍然是一个很好的选择，与下面的代码相比：

 
Remainder = Value % 16;
if( Remainder >= 10 ) Buffer[i] = 'A' + Remainder - 10;
else Buffer[i] = '0' + Remainder;
 

前者显然更加简明、精练，更容易阅读，所以，应根据不同的情况进行取舍。代码中使用了除法和求余运算，有些人很喜欢把这些运算直接用移位代替，以追求极速。但现代编译器对代码的优化已经非常出色，乘除运算与直接移位之间的效率差别已经小到几乎可以忽略不计的程度，除非在需要进行大量数学运算或对效率极其敏感的场合，否则所提高的那么一点微末的速度是无法弥补可读性的损失的。在可读性、空间及效率之间应进行均衡的选择，而不是盲目追求极端。