C++ 遍历 链表

一种使用int*指针来访问链表元素的方法 （并非使用next指针的方法）

编译环境：TDM-GCC 4.9.2 32-Bit Release

众所周知 c与cpp中的链表可以通过结构体或class创建。比如：

class ListNode{

private:

       int val;

public:

       ListNode* next;

       int get(){return  val;}

       ListNode(int v):val(v),next(NULL){

              cout<<"this is a start function\n";

       }

       ListNode(const ListNode& node):val(node.val),next(node.next){

              cout<<"the second start\n";

       }

};

当我们要遍历链表所有元素，一种方法众所周知：

void print(ListNode* head){
	ListNode* cur=head;
	while (cur){
		cout<<cur->val<<" ";
		cur=cur->next;
	}
}

       但我们是否有别的方案来访问链表节点呢换句话说，我们是否可以使用c和c++中的类以及结构体的数据存储特点，来完成对链表节点的访问？

答案是yes！！！

        

前置知识：

在三十二位的情况下，地址大小为4字节，根据结构体地址对齐原则（如果结构成员的大小为4，那么它只会出现在4的倍数的位置上，比如0，4，8，12这样的位置。对size为8的结构变量，它只会出现在0，8，16这样的位置上，通过实践，你会发现class中也适用）。在我们当前这个包含了一个int（4字节）和一个指针（4字节的）的结构体中，它的大小为8。

由于链表的特性，一个node节点中保存当前节点的元素值，以及下一个节点的位置。在我们当前的结构中，int元素和next元素相邻，所以可以通过使指针向后移动一位的方式，拿到当前节点中的next元素的地址（该地址存储着下一个节点的地址信息），然后获取该地址上存着的地址信息，让指针指向那里。这样，我们就集齐了一次访问的所有条件。

核心代码如下：

void printList(ListNode* head){

       int* p=(int* )head;

       ListNode* cur=head;

       while (p!=NULL){

              cout<<*p<<' '<<p;//先打印当前节点的val值，再打印当前节点的起始地址。

              int* ptr=p;//拿到当前地址

              ptr++;//当前地址由val移动到next

              cout<<" the next address is: "<<hex<<ptr<<'\n';/*next的地址输出为十六进制 注意这里我输出的地址只是当前节点的next成员的地址，并不是下一个节点的地址 从这里到附加段之前，所有的输出都是这样*/

              p=(int*)*ptr;//拿到next地址上保存的元素，即链表下一个元素的地址。由于p是指针类型，所以要拿到*ptr后，再做一次强转。

       }

       cout<<'\n';

}

我们看一下运行结果

我们发现地址的访问和我们意想的相符合，印证了我们学习的链表存储方式的正确性。

Ps：这里只保证在32位下的运行，64位的情况下，指针大小为8，你需要移动ptr指针两次才能获得正确的结果：（因为对齐原则）

void printList(ListNode* head){

       int* p=(int* )head;

       while (p!=NULL){

              cout<<*p<<' ';

              int * ptr=p;

              ptr+=2;

              p=(int*)*ptr;

       }

       cout<<'\n';

}

现在我们看一点邪恶的事情，我们知道私有变量的访问限制，我们无法通过直接访问对象私有变量的方式来改变该对象的值，只能通过get和set方法来访问（java的开发者应该对此最为熟悉），如果强行访问的话，编译器会告诉我们结果： val是private的，我们无法直接访问。

（编译报错如下）

 那我们是否可以绕开这一限制，从而来访问私有变量成员，或者修改它呢？

答案是 yes!!!!! 还是通过指针。

为了便于接下来内容的讲解，我们先来看一下递归打印链表的例子，传入参数为const

void recursivePrint(const ListNode* head){
	//为了方便 这里我把val写为public的了 
	if (!head)return;
	//head->val+=1;  //加上这句就会报错 因为修改了const变量
	cout<<head->val<<" ";
	return recursivePrint(head->next);
}

         如果对head修改的话，编译器会提示我们这是一个 read-only object 会编译不过，而且，当我们的val声明为私有成员的话，head->val的访问也会受到限制。

但如果我们使用指针来访问呢（我发出邪恶的笑声hhhhhh）

我们来看实现过程

同样接口的递归函数，在内部我们使用强转指针的方式来访问，会产生意想不到的结果，私有成员和const变量的面纱在强大的指针面前，被揭开了：

void recursivePrint(const ListNode* head){
	int* p=(int*)head;
	if (p== NULL)return;
	(*p)++;//我们做邪恶的事情，对const对象的private成员变量来执行加一操作
	cout<<*p<<" ";
	p++;
	ListNode* next=(ListNode*)*p;//*p取到当前p上存放的下一个节点的地址，然后把它强转为ListNode*
	return recursivePrint(next);//递归访问来遍历链表
}

PS(实际写代码的话，使用这种代码风格，很可能被同事或者队友暴捶，所以自己自娱自乐就行qaq)

让我们看一下运行的效果：打印两次，初值为1，2，3，4，5，6，7，8，9；我们发现当我们执行recursivePrint以后，变为了2，3，4，5，6，7，8，9，10，11；我们单纯靠指针就修改了const 对象的private成员遍历。

 这让我们看到了c和c++中指针的强大性，也提醒了我们这可能带来的安全隐患，毕竟，在熟悉较为底层知识的cpp程序员这里，对象中一切的秘密和限制都不复存在了。

我不知道java中有没有这样的操作，欢迎大家评论留言来告诉我。

附加：

一点有趣的知识点，也是我无意中发现到的：

在当前的32位环境下，

我们打印当前节点的位置，以及它所指向的下一个节点的地址：

我们发现元素地址之间没有什么联系，可以说是随机的位置，符合我们对链表的认知。 

如果切换到clion中使用MinGW64来进行编译运行，（我们之前提过64位下，指针大小为8）会发现一个很有趣的现象：链表的节点地址是连续的。

这几个节点的地址只有后两位是不同的，让我们计算一下距离c8-a8=32, e8-c8=32,两个节点之间距离差值为32，我们的指针一次后移4个单位，也就是说，如果我们让指针自加8，那么理论上也是能访问元素的！

我们试一下：

void printList(ListNode* head){
	int* p=(int* )head;
	while (*p<1000){//我设置的访问控制条件 因为我不会在这种情况判断截至 qaq 有会的老哥教教我
		cout<<*p<<' ';
		int * ptr=p;
		p+=8;
		cout<<" the next address is: "<<hex<<ptr<<'\n';
	//	p=(int*)*ptr;
	}
	cout<<'\n';
}

运行结果如下：

 哈哈哈哈哈哈哈，似乎我们借助平台特性，实现了按照数组顺序访问的方法来访问链表的操作！

如果这篇文章对你有帮助，那不妨在评论区留言吧，2333333。