关于结构体内指针所指向的

[隐无影]

#include <stdio.h>
#include <malloc.h>
#include "SeqList.h"

typedef unsigned int TSeqListNode;

typedef struct _tag_SeqList
{
	int capacity;
	int length;
	TSeqListNode* node;
} TSeqList;//定义结构体

SeqList* SeqList_Create(int capacity) // 传递创建的总数   O(1)
{
	TSeqList* ret = NULL;//创建结构体指针

	if (capacity >= 0)//总数肯定要大于0的
	{
		ret = (TSeqList*)malloc(sizeof(TSeqList)+sizeof(TSeqListNode)* capacity);
		//分配空间一个结构体的空间加上后面数组空间
	}

	if (ret != NULL)//判断是否创建失败
	{
		ret->capacity = capacity;
		ret->length = 0;
		ret->node = (TSeqListNode*)(ret + 1);//创建一个unsigned int 指针
	}

	return ret;
}

void SeqList_Destroy(SeqList* list) // O(1)//创建void *list;
{
	free(list);
}

void SeqList_Clear(SeqList* list) // O(1)//线性表清零
{
	TSeqList* sList = (TSeqList*)list;

	if (sList != NULL)
	{
		sList->length = 0;//把长度清零
	}
}

int SeqList_Length(SeqList* list) // 得到其线性表长度 O(1)
{
	TSeqList* sList = (TSeqList*)list;
	int ret = -1;

	if (sList != NULL)
	{
		ret = sList->length;//
	}

	return ret;
}

int SeqList_Capacity(SeqList* list) //总数  O(1)
{
	TSeqList* sList = (TSeqList*)list;
	int ret = -1;

	if (sList != NULL)
	{
		ret = sList->capacity;
	}

	return ret;
}
                 //传入结构指针,和数据地址,还有 位置
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // 插入O(n) 
{
	TSeqList* sList = (TSeqList*)list;
	int ret = (sList != NULL);
	int i = 0;

	ret = ret && (sList->length + 1 <= sList->capacity);
	ret = ret && (0 <= pos);//表示线性表创建成功

	if (ret)
	{
		if (pos >= sList->length)//如果插入位置大于长度
		{
			pos = sList->length;//就把插入位置放在最后一个
		}

		for (i = sList->length; i>pos; i--)
		{
			sList->node[i] = sList->node[i - 1];//向后移动位置,然后插入
		}

		sList->node[i] = (TSeqListNode)node;//数据就插入这个位置

		sList->length++;
	}

	return ret;
}

SeqListNode* SeqList_Get(SeqList* list, int pos) // O(1) 得到其元素
{
	TSeqList* sList = (TSeqList*)list;//又创建一个结构体指针
	SeqListNode* ret = NULL;//创建空指针

	if ((sList != NULL) && (0 <= pos) && (pos < sList->length))
	{
		ret = (SeqListNode*)(sList->node[pos]);// (SeqListNode*)(sList->node[pos]);这为毛是地址,不是一个数组中的值吗,这是为毛
	}

	return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos) // O(n)
{
	TSeqList* sList = (TSeqList*)list;
	SeqListNode* ret = SeqList_Get(list, pos);
	int i = 0;

	if (ret != NULL)
	{
		for (i = pos + 1; i<sList->length; i++)
		{
			sList->node[i - 1] = sList->node[i];
		}

		sList->length--;
	}

	return ret;
}

// (SeqListNode*)(sList->node[pos]);这为毛是地址,不是一个数组中的值吗,大神求解,哇,这然道不是一个值吗

[一根烂笔头]

没有看到SeqListNode的结构，不过显然是把sList->node[pos]整型值强转成指针了,或许作者用整型变量存储地址了！这是其一 如果SeqListNode是一个unsigned int类型，那么sList->node + pos更合理，也不需要类型转换。

[常书]

指针还是用指针来存比较好，比竟有16位地址，32位地址，64位地址等不同 楼主可以发下SeqListNode的定义

[兜兜很帅]

注意看 ①、 20行 ret = (TSeqList*)malloc(sizeof(TSeqList)+sizeof(TSeqListNode)* capacity); 28行 ret->node = (TSeqListNode*)(ret + 1);//创建一个unsigned int 指针 ②、 75行 int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // 插入O(n)  { . 96行 sList->node[i] = (TSeqListNode)node;//数据就插入这个位置 . } 由这两处可以看出 其存储的确实就对象的指针，获取的时候必然也就是对象的指针喽 同时我可以肯定，在对象释放的时候 肯定还要释放node指针对应的内存，不然就内存泄露了！！！ 这是数据结构存储对象的常用方式，一般都是存储指针，并且该指针的对象一般都是动态开辟出来的内存，不然所指对象生命周期结束，被释放了，那么该指针就成野指针了！

[隐无影]

引用 3 楼 zhangsongtao123 的回复:

注意看 ①、 20行 ret = (TSeqList*)malloc(sizeof(TSeqList)+sizeof(TSeqListNode)* capacity); 28行 ret->node = (TSeqListNode*)(ret + 1);//创建一个unsigned int 指针 ②、 75行 int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // 插入O(n)  { . 96行 sList->node[i] = (TSeqListNode)node;//数据就插入这个位置 . } 由这两处可以看出 其存储的确实就对象的指针，获取的时候必然也就是对象的指针喽 同时我可以肯定，在对象释放的时候 肯定还要释放node指针对应的内存，不然就内存泄露了！！！ 这是数据结构存储对象的常用方式，一般都是存储指针，并且该指针的对象一般都是动态开辟出来的内存，不然所指对象生命周期结束，被释放了，那么该指针就成野指针了！

谢谢我已经懂了,我觉得他把数组元素赋值成地址,开始还不如创建一个指针数组int **node来代替那样,这样更容易理解,对吗,我感觉这样更好,请问这样可不可以

[兜兜很帅]

引用 4 楼 u011391093 的回复:

[quote=引用 3 楼 zhangsongtao123 的回复:] 注意看 ①、 20行 ret = (TSeqList*)malloc(sizeof(TSeqList)+sizeof(TSeqListNode)* capacity); 28行 ret->node = (TSeqListNode*)(ret + 1);//创建一个unsigned int 指针 ②、 75行 int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // 插入O(n)  { . 96行 sList->node[i] = (TSeqListNode)node;//数据就插入这个位置 . } 由这两处可以看出 其存储的确实就对象的指针，获取的时候必然也就是对象的指针喽 同时我可以肯定，在对象释放的时候 肯定还要释放node指针对应的内存，不然就内存泄露了！！！ 这是数据结构存储对象的常用方式，一般都是存储指针，并且该指针的对象一般都是动态开辟出来的内存，不然所指对象生命周期结束，被释放了，那么该指针就成野指针了！

谢谢我已经懂了,我觉得他把数组元素赋值成地址,开始还不如创建一个指针数组int **node来代替那样,这样更容易理解,对吗,我感觉这样更好,请问这样可不可以[/quote] SeqList* SeqList_Create(int capacity) // 传递创建的总数   O(1) {     TSeqList* ret = NULL;//创建结构体指针       if (capacity >= 0)//总数肯定要大于0的     {         ret = (TSeqList*)malloc(sizeof(TSeqList)+sizeof(TSeqListNode)* capacity);         //分配空间一个结构体的空间加上后面数组空间     }       if (ret != NULL)//判断是否创建失败     {         ret->capacity = capacity;         ret->length = 0;         ret->node = (TSeqListNode*)(ret + 1);//创建一个unsigned int 指针     }       return ret; } 由创建的函数可以知道，node指针的所知内存大小以及数据的数量是动态指定，因为new的时候是一块连续的空间，这样做的目的是方便释放内存。 如果按照你的意思，用一串连续的指针来存储数据，不是不可以，是因为难维护，释放的时候还要便利分别释放。 提示一点 int **node 可不是数组指针，自己去查查