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

[Igor95]

Ну,я же не знаю выделяли ли под них память в какой-нибудь подпрограмме. Предположил, что выделяли.
Моя идея такая:

for (int i = 0; i < COUNT; i++)
{
node[i].next[i] = nullptr; // память под *next, как я понял, Вы не выделяли
}
for (int i = 0; i < COUNT; i++)
{
if (node[i].next != nullptr)
{
free(node[i].next);
node[i].next = nullptr;
}
else
{
break;
}
}
free(node);
node = nullptr;

P.S: Писал прямо здесь, не в IDE.
Возможно где-то ошибся.

[Кащей]

Опишите, пожалуйста, словами, как Вы представляете работу функции поиска.

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

Единственное, нет гарантии, что в массиве node[COUNT] все поля next имеют значение NULL

Ну так все поля в NULL поставить не так важно по тому что сейчас все поля гарантированно не NULL. Можно эту проверку опустить.

[BDA]

Как можно разобраться с проблемой, когда, например, я вообще не понимаю, как Вы представляете работу функции traversal, поэтому не могу предложить путей исправления.
На данный момент предлагается к рассмотрению такой код:

#define COUNT 4

typedef unsigned char byte;

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

struct Node*
traversal(byte data, struct Node* node)
{
    if (node == NULL || node->n == data)
        return node;
    int i = 0;
    while (node->next[i] != NULL && node->next[i]->n != data && ++i);
    return node->next[i];
}

int
main(void)
{
    struct Node node[COUNT];
    struct Node* t_node;
    int i, j;

    for (i = 0; i < COUNT; ++i) {
        node[i].n = (i + 1) * 10;
        node[i].next = malloc(sizeof(struct Node*) * COUNT);
        node[i].next[COUNT - 1] = NULL;
        for (j = 0; j < COUNT - 1; ++j)
            node[i].next[j] = &node[(i + j + 1) % COUNT];
    }

    t_node = traversal(21, node);
    if (t_node != NULL)
        printf("%d\n", t_node->n);
    else
        printf("NULL\n");

    for (i = 0; i < COUNT; ++i) {
        free(node[i].next);
        node[i].next = NULL;
    }

    return 0;
}

Тут нет ошибки изменения указателя next у самого элемента Node[0]. При этом, наличие такой "таблицы ссылок" у каждого элемента не имеет никакого смысла, так как поиск осуществляется по ссылкам из 0 элемента.

Насчет использования nullptr - код пишется под Си или С++?

[Кащей]

Как можно разобраться с проблемой, когда, например, я вообще не понимаю, как Вы представляете работу функции traversal, поэтому не могу предложить путей исправления.

Что тут непонятного...есть массив указателей в структуре, который в цикле обходится функцией trawersal, она возвращает адрес структуры с искомым значением(параметр data) если он найден или NULL если доходит до последней ссылки в массиве(саму ссылку).
Это пока всё, тут незачем рассматривать программу целиком, так как вся суть представленного кода в применении функции traversal.

При этом, наличие такой "таблицы ссылок" у каждого элемента не имеет никакого смысла, так как поиск осуществляется по ссылкам из 0 элемента.

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

Насчет использования nullptr - код пишется под Си или С++?

Си

[rrrFer]

Си

забудь о nullptr )

Что тут непонятного...есть массив указателей в структуре, который в цикле обходится функцией trawersal, она возвращает адрес структуры с искомым значением(параметр data) если он найден или NULL если доходит до последней ссылки в массиве(саму ссылку).

Каждый экземпляр Node хранит значение (byte n) и набор ссылок на другие такие же Node : (struct Node** next)." Такие же", значит, что каждый из них также хранит набор ссылок.
Все это смахивает на n-арное дерево, и выглядит нормально.

Но как мне добраться до тех узлов, что расположены ниже первого яруса? - твоя функция traversal выглядит вкорне неверно, в этом случае - она должна быть рекурсивной, а у тебя " массив указателей в структуре, который в цикле обходится..."

Если ты не лезешь дальше первого яруса - я не понимаю нахрена тебе набор укзателей именно на Node и какой выхлоп может получиться с того что ты делаешь (я читал пост, где ты отвечал на этот вопрос, но в коде не вижу ничего похожего).

Мне чето лень разбирать что тут за код тебе постят BDA и Igor95 (они тоже ИМХО не понимают чего ты хочешь добиться), поэтому смотрю в код с первого поста:

while(*node -> next++ != NULL && (*node -> next) -> n != data);
	return **node -> next;

Прикинь, до цикла node->next указывает на элемент перед NULL
выполняется это: *node -> next++
теперь* node->next равен NULL, но выполняется вторая часть условия (ведь с NULL сравнивалась копия *node -> next, созданная до инкремента).
во второй части условия ты выполняешь (*node -> next) -> n
а это уже тоже самое что NULL->n (и тут программа должна падать)

Ну и дальше такое же безобразие происходит.

[Кащей]

Но как мне добраться до тех узлов, что расположены ниже первого яруса?

она должна быть рекурсивной

Вот как раз чтобы отказаться от рекурсии я и мудрю с функцией traversal, она какбы отвечает за выбор ветки в древе.

нахрена тебе набор укзателей именно на Node

По тому как я потом полезу дальше по остальным Nod-ам, незачем думать что раз я щас не лезу, то и потом не полезу.

какой выхлоп может получиться

Даже не знаю что сказать..думай на перспективу.
Например, мне не нужно давать номера структурам(дополнительный id), чтобы получить доступ к данным, связать их, вместо них я пользую указатели, а это экономит память.
Если я захочу смоделировать нейрон в сети, мне не нужно будет гулять по его статическим связям и хранить их в памяти, по тому как связи станут динамическими. Если это база данных, то ненужно дублировать объёмистые данные при записи, это заменяется связями. Можно применить подобную структуру для написания базы данных экспертной системы или семантической сети.

и тут программа должна падать

Но она не падает, по тому как у инкремента приоритет выше.
Это значит что сначала *node -> next++, потом *node -> next != NULL и если вдруг он не равен NULL выполняется сравнение (*node -> next) -> n != data
Я тут не прав, сравнение всёравно проходит и программа падала.

[Кащей]

traversal(byte data, struct Node* node)
{
    if (node == NULL || node->n == data)
        return node;
    int i = 0;
    while (node->next[i] != NULL && node->next[i]->n != data && ++i);
    return node->next[i];
}

Так я смогу сделать в любой момент. Меня интересует именно использование циклов без счётчиков, так как количество ссылок может быть больше диапазона значений переменной используемого типа.
Иначе скажу - ссылки без ограничений, вот что хочется воплотить.

[Кащей]

Пока остановился на этом

struct Node* traversal(byte data, struct Node* node){
	while(*node -> next && (*node -> next) -> n != data && *node -> next++);
	return *node -> next;
}

[BDA]

Обсуждаем последний вариант - Вы изменяете сам указатель next, тем самым разрушая 0 элемент (второй раз поиск будет нельзя осуществить).
ПС Дописывайте свое последнее сообщение, а не пишите несколько подряд (можно заработать штраф).

struct Node*
traversal(byte data, struct Node* node)
{
    if (node == NULL || node->n == data)
        return node;
    if (node->next == NULL)
        return NULL;
    struct Node **t = node->next;
    while (*t != NULL && (*t)->n != data && ++t);
    return *t;
}

Насчет ссылок без ограничений - сама переменная-указатель имеет ограниченный размер (счетчик того же размера сможет "посчитать" больше элементов).

[Кащей]

Итак...как обойти изменение указателя не используя цикл?(вставленный в коде функции main)

    .  .  .

int c;
struct Node* traversal(byte data, struct Node* node){
	while(*node -> next && (*node -> next) -> n != data && *node -> next++)c++;
	return *node -> next;
}
//----------------------------------------------------------------------

    .  .  .

//----------------------------------------------------------------------
int main(void){
	struct Node node[COUNT];
	struct Node* t_node = NULL;
	
	if(create_all(node) == 0)
		t_node = traversal(30, &node[0]);
		for(;c > 0 && *t_node -> next--; c--);

	    .  .  .
	
	return 0;
}