Рассудите функцию, работа с указателями

[Кащей]

Возможно ошибаюсь! Поправьте

Возможно и я ошибаюсь, но чтото мне кажется что скобки там не нужны.

+ после освобождения памяти нужно избавиться от висячих указателей

покажи как.

а что собственно Вы хотите получить?

Охапку знаний.

Для чего нужна такая непонятная структура?

вроде она и не нужна, но я её хочу...
А если серьёзно, это крйне прикольная система контролируемого количества связей между данными вместо дублирования самих данных, элегантная аки рекурсивная функция если сделать как надо. очень неплохо может играть в роли нейросети с изменяемым количеством изменяемых связей. Короче перспектива есть.

[Igor95]

и что, по Вашему мнению, значит такое?:

Node *pNode = ...;
return *pNode -> next;

Я хочу сказать, что вы возвращаете *next, т.е адрес на который указывает next.
Порядок такой:

pNode -> next;
return *next;

Отсюда, скобки я поставил для подчеркивания логики проводимой операции над указателями.

После освобождения памяти указатели содержат "мусор". Избавиться от него можно установив указатель в NULL.

[rrrFer]

Избавиться от него можно установив указатель в NULL.

а лучше, в nullptr

[Igor95]

Не знал, спасибо)

[Кащей]

Вот результат работы по поиску структуры со значениме 30 в переменной n

Адрес структуры содержащей значение 30: 0x7fff40d4c800
Возвращаемый адрес найденной структуры: 0x7fff40d4c800
Значение в структуре с возвращённым адресом: 30

Код не менял..вроде не менял.
Вышибает уже после поиска. Где?

typedef unsigned char byte;

struct Node{
	byte 				n;
	struct Node**		next;
	struct Node*		prev;
};

struct Node* traversal(byte data, struct Node* node){
	while(*node -> next != NULL && (*node -> next) -> n != data && *node -> next++)
	printf("Адрес структуры содержащей значение 30:  %p\nВозвращаемый адрес найденной структуры: %p\n", &node[2], *node -> next);
	return *node -> next;
}

int main(void){
	
        .  .  .
	
	t_node = traversal(30, &node[0]);
	
	if(t_node != NULL) printf("Значение в структуре с возвращённым адресом: %d\n", t_node -> n);

	.  .  .
	
	return 0;
}

Как мы видим - return *node -> next;, возвращает своё значение, тоесть элемент массива указателей, указывающий на структуру, а ты Igor95 говориш, возвращается адрес массива указателей(цитирую:"Адрес на который указывает next"), следовательно заблуждаешся(или можеш отмазаться, по тому как я недопонял, что именно ты имел в виду, но раз уж упрекнул..).

Ошибка свидетельствует о неправильно освобождаемой памяти... Товарищи! помогите правильно память освободить.
И установка указательей в NULL после освобождения памяти ето же не обязательно если указатель использоваться не будет.

Вылетает.. чорт..
Прикладываю код

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define COUNT 4

typedef unsigned char byte;

struct Node{
	byte 				n;
	struct Node**		next;
	struct Node*		prev;
};

struct Node* traversal(byte data, struct Node* node){
	while(*node -> next != NULL)
		if((*node -> next) -> n == data) break;
		else *node -> next++;
		
	return *node -> next;
}
//----------------------------------------------------------------------
void free_all(struct Node* node){
	int i;
		for(i = 0; i < COUNT; i++)
			if(node[i].next != NULL)
				free(node[i].next);
}

int create_all(struct Node* node){
	int i;
		for(i = 0; i < COUNT; i++)
			if(!(node[i].next = malloc(sizeof(struct Node*) * COUNT))){
				free_all(node);
				return -1;
			}
			else{
				node[i].n = (i + 1) * 10;
				node[i].next[3] = NULL;
			}
			
		node[0].next[0] = &node[1];
		node[0].next[1] = &node[2];
		node[0].next[2] = &node[3];
		
		node[1].next[0] = &node[2];
		node[1].next[1] = &node[3];
		node[1].next[2] = &node[0];
		
		node[2].next[0] = &node[3];
		node[2].next[1] = &node[0];
		node[2].next[2] = &node[1];
		
		node[3].next[0] = &node[0];
		node[3].next[1] = &node[1];
		node[3].next[2] = &node[2];
			
	return 0;
}
//----------------------------------------------------------------------
int main(void){
	struct Node node[COUNT];
	struct Node* t_node = NULL;
		
	if(create_all(node) == 0){
	
		t_node = traversal(10, &node[1]);
		
			if(t_node != NULL) printf("%d\n", t_node -> n);
			else puts("\n\n---------->| NULL |<----------\n\n");
		
		free_all(node);
		return 0;
	}
	
	return -1;
}

[Igor95]

Да, перепутал, *next возвращается

Да, а как же вы освобождаете память, выделенную для

next, *next, prev, *prev

?

[Кащей]

Сообщение от Igor95

Да, а как же вы освобождаете память, выделенную для

next, *next, prev, *prev

?

Непонял. Перефразируй пожалуйста.

[Igor95]

Вам ведь нужно правильно память освободить. Т.е, если Вы освободите сначала память, выделенную для Node* node, то это не значит, что освободится и память, выделенная для указателей next, *next, prev, *prev.
Сначала нужно освободить память вышеуказанных указателей, а потом удалить и память, выделенную для Node* node.

[Кащей]

Я исходил из логики - под что память выделяю, то и освобождаю. Тоесть

node[i].next = malloc(sizeof(struct Node*)

free(node[i].next)

Непонятно мне, зачем освобождать указатели под которые память не выдлялась(prev, *prev.)
и не понятно next, *next, откуда?

[BDA]

Сообщение от Кащей

А если серьёзно, это крайне прикольная система контролируемого количества связей между данными вместо дублирования самих данных, элегантная аки рекурсивная функция если сделать как надо. очень неплохо может играть в роли нейросети с изменяемым количеством изменяемых связей. Короче перспектива есть.

Возможно это имело бы смысл, если бы выбор следующего элемента был более сложным. Пока же, при переборе всех элементов последовательно, никакого профита не вижу. Тем более, что в текущей реализации Вы изменяете указатель next, хранящийся в 0 элементе массива node[COUNT]. Опишите, пожалуйста, словами, как Вы представляете работу функции поиска.

Насчет спора про освобождение - все верно (что выделили, то и освободили). Единственное, нет гарантии, что в массиве node[COUNT] все поля next имеют значение NULL (это к вопросу о проверке if(node[i].next != NULL) free(node[i].next); в free_all).