Контейнеры в Си, . Опции

[Neonig]

Помогите разобраться с заданием пожалуйста.
Вот по этому адресу (адрес указан в приложенном файле) лежит задание для нас. Там правда сказано на С++ без ООП, но преподаватель сказал, что на НАМ нужно на чистом Си. В файле на сайте все написанное и приведены три задания: двусвязный линейный список, ассоциативный массив и динамический массив. В Листинге который я выложу дальше я по идеи реализовал первое задание - линейный список - очень прошу специалистов посмотреть и высказать замечания, где может не правильно, где недодумано, где ещё чего. Вторая просьба - это пояснить, как основываясь на интерфейсе списков сделать динамический массив (это всё в здании написано просто коротко напоминаю) и что из себя таки представляет этот ассоциативный массив в примитивной реализации... не прошу написать, прошу объяснить как на основе сделанного прийти ко всему остальному.
С уважением

!

Второй раз говорю, прочитай правила форума

Сообщение отредактировано: klem4 - 23.09.2007 8:06

[volvo]

Вот по этому адресу (адрес указан в приложенном файле) лежит задание для нас.

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

[Neonig]

Извини пожалуйста, сейчас скачаю и прилеплю....Только задание находится на вполне таком официальном сайте универа, что сразу видно по названию, можно я ссылку оставлю, а то перерисовывать сюда таблицы и всё такое будет сложно.... ccfit.nsu.ru/~den/CPP/Task1.doc

[Neonig]

сам исходник.
Условия в посте выше, цель вопроса, в первом сообщении, надеюсь на вашу помощь

Код

#include <stdio.h>
#include <stdlib.h>
#include "LinkedList.h"


void* cont_allocate()
{
    static AL *cont_v;
    void* from_al_to_void;
    cont_v = (AL*)malloc(sizeof(AL));
    from_al_to_void = &cont_v;
    cont_v->count = count;
    count++;
    cont_v->data = NULL;
    cont_v->Prev = NULL;
    cont_v->Next = NULL;
    return from_al_to_void;
}


void  cont_add(void* cont, void* data)
{
    AL *cont_insert;
    AL *from_cont_to_alstruct;
    int schet = 0;

    from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
    cont_insert = (AL*)malloc(sizeof(AL));
    from_cont_to_alstruct = (AL*) cont;
    while(from_cont_to_alstruct->Next)
    {
            from_cont_to_alstruct = from_cont_to_alstruct->Next;
            schet++;
    }
    from_cont_to_alstruct->Next = cont_insert;
    cont_insert->Prev = from_cont_to_alstruct;
    cont_insert->data = data;
    cont_insert->count = schet++;
    cont_insert->Next = NULL;
}

void  cont_insert(void* cont, int pos, void* data)
{
    int shet = 0;
    AL *from_cont_to_alstruct;
    AL *pos_insert;
    
    from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
    pos_insert = (AL*)malloc(sizeof(AL));
    from_cont_to_alstruct = (AL*)cont;
    while(((from_cont_to_alstruct->count)!= pos) || (from_cont_to_alstruct->Next))
    {
        from_cont_to_alstruct = from_cont_to_alstruct->Next;
        shet++;
    }
    
    pos_insert->Next = from_cont_to_alstruct->Next;
    from_cont_to_alstruct->Next = pos_insert;
    pos_insert->Prev = from_cont_to_alstruct;
    pos_insert->data = data;
}

int   cont_size(void* cont)
{
    AL *from_cont_to_alstruct;
    int razm_cont = 0;

    from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
    from_cont_to_alstruct = (AL*)cont;
    
    while(from_cont_to_alstruct->Next)
    {
        from_cont_to_alstruct = from_cont_to_alstruct->Next;
        razm_cont++;
    }
    return razm_cont;
}


void* cont_get(void* cont, int pos)
{
    AL *from_cont_to_alstruct;
    void* insert_data;

    from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
    from_cont_to_alstruct = (AL*)cont;

    while(((from_cont_to_alstruct->count)!=pos) || (from_cont_to_alstruct->Next))
    {
        from_cont_to_alstruct = from_cont_to_alstruct->Next;
    }

    insert_data = from_cont_to_alstruct->data;
    return insert_data;
}


void* cont_replace(void* cont, int pos, void* data)
{
    AL *from_cont_to_alstruct;
    void *lost_data;
    
    from_cont_to_alstruct = (AL*)malloc(sizeof(AL));

    while ( ((from_cont_to_alstruct->count)!=pos) || (from_cont_to_alstruct->Next))
    {
        from_cont_to_alstruct = from_cont_to_alstruct->Next;    
    }

    lost_data = from_cont_to_alstruct->data;
    from_cont_to_alstruct->data = data;
    return lost_data;
}


void* cont_remove(void* cont, int pos)
{
    AL *from_cont_to_alstruct;
    AL *vrem_xran;
    void *lost_data;
    
    from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
    vrem_xran = (AL*)malloc(sizeof(AL));
    from_cont_to_alstruct = (AL*)cont;
    while ( ((from_cont_to_alstruct->count)!=pos) || (from_cont_to_alstruct->Next))
    {
        from_cont_to_alstruct = from_cont_to_alstruct->Next;    
    }
    lost_data = from_cont_to_alstruct->data;
    from_cont_to_alstruct->Prev->Next = from_cont_to_alstruct->Next;
    from_cont_to_alstruct->Next->Prev = from_cont_to_alstruct->Prev;
    from_cont_to_alstruct->Next = NULL;
    from_cont_to_alstruct->Prev = NULL;
    free(from_cont_to_alstruct);
    return vrem_xran;
}

void  cont_foreach(void* cont/*, cont_handle*/)
{
    AL *from_cont_to_alstruct;

    from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
    from_cont_to_alstruct = (AL*)cont;

    while(from_cont_to_alstruct->Next)
    {
//        cont_handle(from_cont_to_alstruct);
        from_cont_to_alstruct = from_cont_to_alstruct->Next;
    }
}


void  cont_foreach_reverse(void* cont/*, cont_handle*/)
{
    AL *from_cont_to_alstruct;

    from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
    from_cont_to_alstruct = (AL*)cont;

    while(from_cont_to_alstruct->Next)
    {
        from_cont_to_alstruct = from_cont_to_alstruct->Next;
    }

    while(from_cont_to_alstruct->Prev)
    {
//      cont_handle(from_cont_to_alstructr);
        from_cont_to_alstruct = from_cont_to_alstruct->Prev;
    }
}


void  cont_release(void* cont)
{
    AL *from_cont_to_alstruct;

    from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
    from_cont_to_alstruct = (AL*)cont;

    while(from_cont_to_alstruct->Next)
    {
        from_cont_to_alstruct = from_cont_to_alstruct->Next;
    }

    while(from_cont_to_alstruct->Prev)
    {
        from_cont_to_alstruct = from_cont_to_alstruct->Prev;
        free(from_cont_to_alstruct);
    }
}

Сообщение отредактировано: Neonig - 22.09.2007 22:29

[volvo]

У тебя в коде есть утечки памяти, или мне кажется? Вот это, например, что такое:

int   cont_size(void* cont)
{
    AL *from_cont_to_alstruct;
    int razm_cont = 0;

    from_cont_to_alstruct = (AL*)malloc(sizeof(AL)); // Выделил память ...
    from_cont_to_alstruct = (AL*)cont; // ... и тут же благополучно об этом забыл?
    
    while(from_cont_to_alstruct->Next)
    {
        from_cont_to_alstruct = from_cont_to_alstruct->Next;
        razm_cont++;
    }
    return razm_cont;
}

?

Второе... Вот тут:

void  cont_add(void* cont, void* data)
{
    AL *cont_insert;
    AL *from_cont_to_alstruct;
    int schet = 0;

    from_cont_to_alstruct = (AL*)malloc(sizeof(AL)); // <--- зачем выделяется память? Опять утечка ...
    cont_insert = (AL*)malloc(sizeof(AL));
    from_cont_to_alstruct = (AL*) cont;
    while(from_cont_to_alstruct->Next)
    {
            from_cont_to_alstruct = from_cont_to_alstruct->Next;
            schet++;
    }
    from_cont_to_alstruct->Next = cont_insert;
    cont_insert->Prev = from_cont_to_alstruct;
    cont_insert->data = data;
    cont_insert->count = schet++; // Мелочь, но зачем ++? Ты же все равно выходишь из функции...
    cont_insert->Next = NULL;
}

Да и вообще, я бы посмотрел в сторону повторного использования функций... А то ты каждый раз делаешь "все внутри себя", а ведь если чуть-чуть подкорректировать, например, функцию cont_size, то можно будет значительно уменьшить размер кода за счет того, что те же самые действия не будут выполняться, например, в cont_add/cont_get/cont_replace, а будет вызываться cont_size...

[Neonig]

[quote name='volvo' date='23.09.2007 10:42' post='109904']
У тебя в коде есть утечки памяти, или мне кажется? Вот это, например, что такое:

int   cont_size(void* cont)
{
    AL *from_cont_to_alstruct;
    int razm_cont = 0;

    from_cont_to_alstruct = (AL*)malloc(sizeof(AL)); // Выделил память ...
    from_cont_to_alstruct = (AL*)cont; // ... и тут же благополучно об этом забыл?
    
    while(from_cont_to_alstruct->Next)
    {
        from_cont_to_alstruct = from_cont_to_alstruct->Next;
        razm_cont++;
    }
    return razm_cont;
}

?

Второе... Вот тут:

void  cont_add(void* cont, void* data)
{
    AL *cont_insert;
    AL *from_cont_to_alstruct;
    int schet = 0;

    from_cont_to_alstruct = (AL*)malloc(sizeof(AL)); // <--- зачем выделяется память? Опять утечка ...
    cont_insert = (AL*)malloc(sizeof(AL));
    from_cont_to_alstruct = (AL*) cont;
    while(from_cont_to_alstruct->Next)
    {
            from_cont_to_alstruct = from_cont_to_alstruct->Next;
            schet++;
    }
    from_cont_to_alstruct->Next = cont_insert;
    cont_insert->Prev = from_cont_to_alstruct;
    cont_insert->data = data;
    cont_insert->count = schet++; // Мелочь, но зачем ++? Ты же все равно выходишь из функции...
    cont_insert->Next = NULL;
}

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

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

Если не трудно скажи, а в какой момент нужно память освобождать, даже если я пойму почему выделение памяти лишнее и уберу его, то все равно иногда оно встречается по необходимости - где её освободить?


Ну и наконец, тут чтобы более не нарушить правил скажу так... вот есть ещё два задания. Худо бедно, но это (линейный двусвязанный список) сделано, но требует серьёзной доработки (потому я все выспрашиваю, чтобы понять), а вот другие два задания мне не понятны просто - Динамический массив на основе этого списка (т.е. те же функции что и для списка, но теперь релизнуть на них надо динамический массив) - что это, что теперь делают функции, в чем особенность - не могу понять и всё... и наконец Ассоциативный массив, о чем он я примерно понял, интерфейс этого массива заключается в добавлении поля кей в каждую функцию, но сути я не понял, что за структура, то должно подаваться -сути не понимаю...

[volvo]

я думал всегда нужно выделять память...

Смотри:

void  cont_add(void* cont, void* data)
{
    AL *cont_insert;
    AL *from_cont_to_alstruct;
    int schet = 0;

    cont_insert = (AL*)malloc(sizeof(AL)); // Это ты выделил память под новый элемент

    // Для добавления очередного элемента к контейнеру все, что тебе нужно - 
    // это найти такой элемент, поле Next которого равно NULL ... 
    for(from_cont_to_alstruct = (AL*)cont; // начинаем искать с начала контейнера
        from_cont_to_alstruct->Next; // пока поле Next ненулевое
        from_cont_to_alstruct = from_cont_to_alstruct->Next // на каждой итерации продвигаемся дальше
    ) schet++; // собственно, в цикле увеличиваем счетчик

    // Хорошо... КУДА присоединять нашли, теперь надо присоединить...
    from_cont_to_alstruct->Next = cont_insert; // к "хвосту" добавляем ранее выделенный элемент
    cont_insert->Prev = from_cont_to_alstruct; // обратная связь
    cont_insert->data = data; 
    cont_insert->count = schet; // Вот тут достаточно просто присвоить полю count значение schet:
                                // увеличивать schet _после_ запоминания совсем не обязательно...
    cont_insert->Next = NULL;
}

а в какой момент нужно память освобождать

Когда будешь удалять элемент контейнера, в частности в функции cont_remove (free там, кстати, у тебя уже есть).

[Neonig]

Ясно, значит переделаю остальные моменты под этот стиль... остался тогда толкьо вопрос касательно Динамического массива на оснвое этого же интерфейса и ассоциаивный массив..прошу помочь с теорией, и объяснить что это такое. Первое - какя паралель между динам массивом и списком, второе - что вообще сделать чтобы похожий интерейс работал с ассоциативным массивом (да и что он тако есть в целом)

[volvo]

Я не знаю, чего ждут от тебя в этом задании (какой смысл переписывать вручную уже готовые и намного более функциональные std::list, std::vector и std::map - я не понимаю), но могу привести основные различия между std::list и std::vector:

Список (std::list) отличается от динамического массива (std::vector) следующим:
- список не предусматривает прямого доступа. Если Вам нужно получить доступ к 5-му элементу списка, Вы обязаны перед этим пройти по предшествующим ему 4-м элементам. Таким образом, доступ к элементу в списке замедляется;
- вставка и удаление элементов производятся быстро в любой позиции, а не только с концов списка. Вы всегда можете удалить или добавить элемент за константное время, поскольку другие элементы при этом не должны перемещаться. Изменяются только несколько внутренних указателей.

Теперь о массиве:

- массив - это упорядоченная коллекция. К элементам массива возможен прямой доступ (random access). То есть, Вы можете обратиться к любому элементу массива за константное время;
- массив обеспечивает наилучшее быстродействие при добавлении/удалении элементов с конца. При работе с началом/серединой массива быстродействие ухудшается. Это происходит потому, что следующие за удаленным/добавленным элементом должны быть сдвинуты в другую позицию.

Если надо - могу написать, что представляет из себя map (ассоциативный массив) с точки зрения STL...

[Neonig]

Я не знаю, чего ждут от тебя в этом задании (какой смысл переписывать вручную уже готовые и намного более функциональные std::list, std::vector и std::map - я не понимаю), но могу привести основные различия между std::list и std::vector:
Теперь о массиве:
Если надо - могу написать, что представляет из себя map (ассоциативный массив) с точки зрения STL...

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

На счет мапа - буду очень благодарен, если пояснишь...

[volvo]

ведь унтри всеравно придется бегать по всем структурам

если сделать в cont_allocate выделение массива, скажем, под 20-30 указателей на структуры, и в cont_get не бегать по предыдущим элементам, а сразу отправляться по соответствующему указателю - то не придется...

А насчет map - посмотри вот тут (по-русски) или тут: SGI: map (по-английски)

[Neonig]

если сделать в cont_allocate выделение массива, скажем, под 20-30 указателей на структуры, и в cont_get не бегать по предыдущим элементам, а сразу отправляться по соответствующему указателю - то не придется...

А насчет map - посмотри вот тут (по-русски) или тут: SGI: map (по-английски)

Т.е. достаточно разговор с последовательности структур перевести на массив структур и всё? А как сразу переходить по указателю - мне же дается позиция, как мне не проходя все подрядд сразу в этой позиции оказаться...?

[volvo]

как мне не проходя все подрядд сразу в этой позиции оказаться...?

AL **array, *current;
array = (AL **)malloc(20 * sizeof(AL*));

// ну, тут заполнение массива array

current = array[3]; // <--- Как ты думаешь, что будет содержаться в current? Не array[3] ? ...

... но я же не обращался ни к array[0], ни к array[1].

Сообщение отредактировано: volvo - 24.09.2007 16:12

[Neonig]

Вот глнянь на общие принципы того ,как я это понял ...

void* cont_allocatet()
{
	void** cont_array; //массив указателей
	AR  *first_struct_array; // структура на которую я буду ссылаться в каждой ячейке

	first_struct_array = (AR*)malloc(sizeof(AR)); // выделяю память под эту структуру, и заполняю
/*
только вот с заполнением не ясно, а на что теперь ссылается некст и прев
и как это оформить - ходить по ячейкам массива или выискивать адрес следующей
структуры в общем пошел для меня темный лес...
*/

	cont_array=(void**) malloc(sizeof(AR)*10); // выделяю память для массива нашего

	cont_array[0] = &first_struct_array; // первой ячейке (она же вроде ссылается на указатель)
// передаю адрес этой структуры.... 
	
	return cont_array[0];
}

вот кая я понял, если не трудно скажи где не прав, где не допонял....? Ещё такой вопрос, препод сказал, что может получиться дескать нет места добавить жлемент и типо нужно расширить память и скопировать старый массив в новый - большой... а как этот лимит памяти проверять?

[Neonig]

Вот, я сделал ещё динамический массив... посмотрите пожалуйста....

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

#ifndef CONTAINER_H
#define CONTAINER_H

//	#define ARRAY
	#define LIST

	typedef void(*cont_handle)(void* data);

// Создает пустой контейнер !!!***
	void* cont_allocate();
// Удаляет контейнер!!!***
	void  cont_release(void* cont);
// Добавляет элемент в конец контейнера !!!***
	void  cont_add(void* cont, void* data);
// Вставляет злемент в позицию pos  !!!***
	void  cont_insert(void* cont, int pos, void* data);
// Возвращает размер контейнера	 !!!*** 
	int   cont_size(void* cont);
// Возвращает данные в позиции pos  !!!***
	void* cont_get(void* cont, int pos);
// Заменяет данные в позиции pos. Возвращает старые данные.!!!***
	void* cont_replace(void* cont, int pos, void* data);
// Удаляет данные из позиции pos. Возвращает удаленные данные.
	void* cont_remove(void* cont, int pos);
// Перебирает все элементы контейнера по порядку. !!!***
	void  cont_foreach(void* cont/*, cont_handle proc*/);
// Перебирает все элементы контейнера в обратном порядке.!!!***
	void  cont_foreach_reverse(void* cont, cont_handle proc);

#endif


#ifndef ARRAYLIST_H
#define AARAYLIST_H

	typedef struct ArrayListt{
		void** data;
		int count_size;
	} AR;

	AR *cont;

#endif





#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
#include "ArrayList.h"
#include "Container.h"

#ifdef ARRAY 

	static int error_done = 0;
	#define mem_to_alloc(dyn) if (!(dyn)) {error_done = 1; return NULL;}

	void* cont_allocate()
	{
		AR *struct_dyn;

		struct_dyn = (AR*)malloc(sizeof(AR*));
		mem_to_alloc(struct_dyn);
		if (error_done = 1)
		{
			printf("$s", "Error mam allocated");
			error_done = 0;
		}
		else
			printf("%s", "OK");

		struct_dyn->count_size = NULL;
		struct_dyn->data = (void**)malloc(sizeof(void**));
		struct_dyn->data = NULL;
		return (void*)struct_dyn;
	}

	void  cont_release(void* cont)
	{
		AR *vrem_cont_array;
	
		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		vrem_cont_array = (AR*)cont;
		free(vrem_cont_array->data);
		free(vrem_cont_array);
	}

	void  cont_add(void* cont, void* data)
	{
		AR *vrem_cont_array;
		void **vrem_mass;
		int count_one = 0; 
		int count_two = 0;
		int mass_size = 0;
	
		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		
		vrem_cont_array = (AR*)cont;	

		mass_size = vrem_cont_array->count_size;	
		vrem_mass = (void**)malloc(sizeof(mass_size+1));
		vrem_cont_array->count_size = mass_size++;

		for(count_one = 0; count_one <= mass_size; count_one +=1)
		{
			vrem_mass[count_one] = vrem_cont_array->data[count_one];
		}
		
		mass_size =+1;
		vrem_mass[mass_size] = (void**)data;

		vrem_cont_array = (AR*)realloc(vrem_cont_array, sizeof(mass_size+1));

		for(count_two = 0; count_two <= mass_size; count_two +=1)
		{
			vrem_cont_array->data[count_two] = vrem_mass[count_two]; 
		}
	}

	void  cont_insert(void* cont, int pos, void* data)
	{
		AR *vrem_cont_array;
		void **vrem_mass;
		int count_one   = 0; 
		int count_two   = 0;
		int count_three = 0;
		int mass_size   = 0;
	
		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		vrem_cont_array = (AR*)cont;

		mass_size = vrem_cont_array->count_size;	
		vrem_mass = (void**)malloc(sizeof(mass_size+1));
		vrem_cont_array->count_size = mass_size++;
	
		for(count_one = 0; count_one <= pos - 1; count_one += 1)
		{
			vrem_mass[count_one] = vrem_cont_array->data[count_one];
		}

		for(count_two = pos+1; count_two <= mass_size; count_one +=1)
		{
			vrem_mass[count_one] = vrem_cont_array->data[count_two];
		}

		vrem_mass[pos] = data;

		vrem_cont_array = (AR*)realloc(vrem_cont_array, sizeof(mass_size+1));

		mass_size += 1;
	
		for(count_three = 0; count_three <= mass_size; count_three +=1)
		{
			vrem_cont_array->data[count_three] = vrem_mass[count_three];	
		}	
	}

	int   cont_size(void* cont)
	{
		AR* vrem_cont_array;
		int mass_size = 0;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		mass_size = vrem_cont_array->count_size;
	
		return mass_size;
	}


	void* cont_get(void* cont, int pos)
	{
		AR *vrem_cont_array;
		void* vrem_data;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		vrem_data = (void*)malloc(sizeof(void*));
		vrem_data = vrem_cont_array->data[pos];
	
		return vrem_data;
	}


	void* cont_replace(void* cont, int pos, void* data)
	{
		AR *vrem_cont_array;
		void* vrem_data;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		vrem_data	   = (void*)malloc(sizeof(void*));
		vrem_data = vrem_cont_array->data[pos];
		vrem_cont_array->data[pos] = data;

		return vrem_data;
	}

	void* cont_remove(void* cont, int pos)
	{
		AR *vrem_cont_array;
		void* vrem_data;
		void** vrem_mass;
		int count_one	= 0;
		int count_two	= 0;
		int count_three  = 0;
		int vrem		 = 0;
		int mass_size	= 0;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		vrem_data	   = (void*)malloc(sizeof(void*));
		vrem_mass	   = (void**)malloc(sizeof(void**));
		mass_size	   =  vrem_cont_array->count_size;
	
		vrem = pos;
		vrem_data = vrem_cont_array->data[pos]; 

		for(count_one = pos; count_one < mass_size; count_one += 1)
		{
			vrem_cont_array->data[count_one] = vrem_cont_array->data[count_one+1];
		}

		mass_size -= 1;	

		for(count_two = 0; count_two < mass_size; mass_size += 1)
		{
			vrem_mass[count_two] = vrem_cont_array->data[count_two];	
		}
	
		free(vrem_cont_array->data);
		vrem_cont_array->data = (void**)malloc(sizeof(void**)*mass_size);

		for(count_three = 0; count_three < mass_size; count_three += 1)
		{
			vrem_cont_array->data[count_three] = vrem_mass[count_three];	
		}
	
		vrem_cont_array->count_size -= 1;

		return vrem_data;
	}


	void  cont_foreach(void* cont/*, cont_handle proc*/)
	{
		AR* vrem_cont_array;
		int mass_size = 0;
		int count_one = 0;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		mass_size = vrem_cont_array->count_size;
	
		for(count_one = 0; count_one <= mass_size; count_one += 1)
		{
			// cont_handle(vrem_cont_array->data[count_one]);
		}
	}

	void  cont_foreach_reverse(void* cont/*, cont_handle proc*/)
	{
		AR* vrem_cont_array;
		int mass_size = 0;
		int count_one = 0;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		mass_size = vrem_cont_array->count_size;

		for(count_one = mass_size; count_one >= 0; count_one -= 1)
		{
			// cont_handle(vrem_cont_array->data[count_one]);	
		}
	}
#endif ARRAY

[volvo]

Пример которы я скинул по двусвязанному списку - почему то не работает

А ты пример как раз ни один не привел, только реализацию самих функций... Поэтому и ответов не получаешь. Ну не хочется мне выдумывать пример использования, задание, прости, дали тебе - вот и придумывай. А если что не получается - то давай не обрывки кода, а ВЕСЬ код... Включая и тестовую программу. Ибо у меня то, что ты привел не имеет шанса даже откомпилироваться - main() не присутствует...

[Neonig]

Понял тебя...извини, что - то реально затупил с постановкой вопроса.... првожу все файлы... Смысл такой, я создаю контейнер и добавляю в него 10 элементов, где данные - это прядковый номер каждого. Эти две функции вроде пашут, следующая - это прокрутка всего контейнера с применеием некой функции к нему - я хотел, чтобы при прокрутке принтэфились эти числа, что я заносил...но ничего не происходит . в лучем случае программа запускается демонстрирует пустой экран и закрывается -в худшев уходит в ссылку на ошибку в какоам - то закрытом сишном файле....

Компилятор Visual Studio 2008 Beta 2, но и на VS 2005 она не блещет работоспособностью...

Array List.H:

#ifndef ARRAYLIST_H
#define AARAYLIST_H

	typedef struct ArrayListt{
		void** data;
		int count_size;
	} AR;

	AR *cont;

#endif

Container.h:

#ifndef CONTAINER_H
#define CONTAINER_H

//	#define ARRAY
	#define LIST

	typedef void(*cont_handle)(void* data);

// Создает пустой контейнер !!!***
	void* cont_allocate();
// Удаляет контейнер!!!***
	void  cont_release(void* cont);
// Добавляет элемент в конец контейнера !!!***
	void  cont_add(void* cont, void* data);
// Вставляет злемент в позицию pos  !!!***
	void  cont_insert(void* cont, int pos, void* data);
// Возвращает размер контейнера	 !!!*** 
	int   cont_size(void* cont);
// Возвращает данные в позиции pos  !!!***
	void* cont_get(void* cont, int pos);
// Заменяет данные в позиции pos. Возвращает старые данные.!!!***
	void* cont_replace(void* cont, int pos, void* data);
// Удаляет данные из позиции pos. Возвращает удаленные данные.
	void* cont_remove(void* cont, int pos);
// Перебирает все элементы контейнера по порядку. !!!***
	void  cont_foreach(void* cont/*, cont_handle proc*/);
// Перебирает все элементы контейнера в обратном порядке.!!!***
	void  cont_foreach_reverse(void* cont, cont_handle proc);

#endif

LinkedList.h:

#ifndef LINKEDLIST_H
#define LINKEDLIST_H
	
	typedef struct ArrayList{
		struct ArrayList *Prev;
		struct ArrayList *Next;
		void* data;
		int count;
	} AL;

	AL *cont;
	static int count = 0;

#endif

Arraylist.cpp

#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
#include "ArrayList.h"
#include "Container.h"

#ifdef ARRAY 

	static int error_done = 0;
	#define mem_to_alloc(dyn) if (!(dyn)) {error_done = 1; return NULL;}

	void* cont_allocate()
	{
		AR *struct_dyn;

		struct_dyn = (AR*)malloc(sizeof(AR*));
		mem_to_alloc(struct_dyn);
		if (error_done = 1)
		{
			printf("$s", "Error mam allocated");
			error_done = 0;
		}
		else
			printf("%s", "OK");

		struct_dyn->count_size = NULL;
		struct_dyn->data = (void**)malloc(sizeof(void**));
		struct_dyn->data = NULL;
		return (void*)struct_dyn;
	}

	void  cont_release(void* cont)
	{
		AR *vrem_cont_array;
	
		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		vrem_cont_array = (AR*)cont;
		free(vrem_cont_array->data);
		free(vrem_cont_array);
	}

	void  cont_add(void* cont, void* data)
	{
		AR *vrem_cont_array;
		void **vrem_mass;
		int count_one = 0; 
		int count_two = 0;
		int mass_size = 0;
	
		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		
		vrem_cont_array = (AR*)cont;	

		mass_size = vrem_cont_array->count_size;	
		vrem_mass = (void**)malloc(sizeof(mass_size+1));
		vrem_cont_array->count_size = mass_size++;

		for(count_one = 0; count_one <= mass_size; count_one +=1)
		{
			vrem_mass[count_one] = vrem_cont_array->data[count_one];
		}
		
		mass_size =+1;
		vrem_mass[mass_size] = (void**)data;

		vrem_cont_array = (AR*)realloc(vrem_cont_array, sizeof(mass_size+1));

		for(count_two = 0; count_two <= mass_size; count_two +=1)
		{
			vrem_cont_array->data[count_two] = vrem_mass[count_two]; 
		}
	}

	void  cont_insert(void* cont, int pos, void* data)
	{
		AR *vrem_cont_array;
		void **vrem_mass;
		int count_one   = 0; 
		int count_two   = 0;
		int count_three = 0;
		int mass_size   = 0;
	
		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		vrem_cont_array = (AR*)cont;

		mass_size = vrem_cont_array->count_size;	
		vrem_mass = (void**)malloc(sizeof(mass_size+1));
		vrem_cont_array->count_size = mass_size++;
	
		for(count_one = 0; count_one <= pos - 1; count_one += 1)
		{
			vrem_mass[count_one] = vrem_cont_array->data[count_one];
		}

		for(count_two = pos+1; count_two <= mass_size; count_one +=1)
		{
			vrem_mass[count_one] = vrem_cont_array->data[count_two];
		}

		vrem_mass[pos] = data;

		vrem_cont_array = (AR*)realloc(vrem_cont_array, sizeof(mass_size+1));

		mass_size += 1;
	
		for(count_three = 0; count_three <= mass_size; count_three +=1)
		{
			vrem_cont_array->data[count_three] = vrem_mass[count_three];	
		}	
	}

	int   cont_size(void* cont)
	{
		AR* vrem_cont_array;
		int mass_size = 0;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		mass_size = vrem_cont_array->count_size;
	
		return mass_size;
	}


	void* cont_get(void* cont, int pos)
	{
		AR *vrem_cont_array;
		void* vrem_data;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		vrem_data = (void*)malloc(sizeof(void*));
		vrem_data = vrem_cont_array->data[pos];
	
		return vrem_data;
	}


	void* cont_replace(void* cont, int pos, void* data)
	{
		AR *vrem_cont_array;
		void* vrem_data;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		vrem_data	   = (void*)malloc(sizeof(void*));
		vrem_data = vrem_cont_array->data[pos];
		vrem_cont_array->data[pos] = data;

		return vrem_data;
	}

	void* cont_remove(void* cont, int pos)
	{
		AR *vrem_cont_array;
		void* vrem_data;
		void** vrem_mass;
		int count_one	= 0;
		int count_two	= 0;
		int count_three  = 0;
		int vrem		 = 0;
		int mass_size	= 0;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		vrem_data	   = (void*)malloc(sizeof(void*));
		vrem_mass	   = (void**)malloc(sizeof(void**));
		mass_size	   =  vrem_cont_array->count_size;
	
		vrem = pos;
		vrem_data = vrem_cont_array->data[pos]; 

		for(count_one = pos; count_one < mass_size; count_one += 1)
		{
			vrem_cont_array->data[count_one] = vrem_cont_array->data[count_one+1];
		}

		mass_size -= 1;	

		for(count_two = 0; count_two < mass_size; mass_size += 1)
		{
			vrem_mass[count_two] = vrem_cont_array->data[count_two];	
		}
	
		free(vrem_cont_array->data);
		vrem_cont_array->data = (void**)malloc(sizeof(void**)*mass_size);

		for(count_three = 0; count_three < mass_size; count_three += 1)
		{
			vrem_cont_array->data[count_three] = vrem_mass[count_three];	
		}
	
		vrem_cont_array->count_size -= 1;

		return vrem_data;
	}


	void  cont_foreach(void* cont/*, cont_handle proc*/)
	{
		AR* vrem_cont_array;
		int mass_size = 0;
		int count_one = 0;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		mass_size = vrem_cont_array->count_size;
	
		for(count_one = 0; count_one <= mass_size; count_one += 1)
		{
			// cont_handle(vrem_cont_array->data[count_one]);
		}
	}

	void  cont_foreach_reverse(void* cont/*, cont_handle proc*/)
	{
		AR* vrem_cont_array;
		int mass_size = 0;
		int count_one = 0;

		vrem_cont_array = (AR*)malloc(sizeof(AR*));
		mass_size = vrem_cont_array->count_size;

		for(count_one = mass_size; count_one >= 0; count_one -= 1)
		{
			// cont_handle(vrem_cont_array->data[count_one]);	
		}
	}
#endif ARRAY

LinkedList.cpp:

#include <stdio.h>
#include <stdlib.h>
#include "LinkedList.h"

//#ifdef LIST
	void* cont_allocate()
	{
		static AL *cont_v;
		void* from_al_to_void;

		cont_v = (AL*)malloc(sizeof(AL));
		cont_v->count = count;
		count++;
		cont_v->data = NULL;
		cont_v->Prev = NULL;
		cont_v->Next = NULL;
		
		return (void*)cont_v;
	}

	void  cont_add(void* cont, void* data)
	{
		AL *cont_insert;
		AL *from_cont_to_alstruct;
		int schet = 0;
		from_cont_to_alstruct = (AL*) cont;
		
		
		while(from_cont_to_alstruct->Next!=NULL)
		{
			from_cont_to_alstruct = from_cont_to_alstruct->Next;
			schet++;
		}
		
		
		cont_insert = (AL*)malloc(sizeof(AL));
		
		from_cont_to_alstruct->Next = cont_insert;
		cont_insert->Prev = from_cont_to_alstruct;
		cont_insert->data = data;
		cont_insert->count = schet++;
		cont_insert->Next = NULL;
	}

	void  cont_insert(void* cont, int pos, void* data)
	{
		int shet = 0;
		AL *from_cont_to_alstruct;
		AL *pos_insert;
	
		from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
		pos_insert = (AL*)malloc(sizeof(AL));
		from_cont_to_alstruct = (AL*)cont;
		while(((from_cont_to_alstruct->count)!= pos) || (from_cont_to_alstruct->Next))
		{
			from_cont_to_alstruct = from_cont_to_alstruct->Next;
			shet++;
		}
	
		pos_insert->Next = from_cont_to_alstruct->Next;
		from_cont_to_alstruct->Next = pos_insert;
		pos_insert->Prev = from_cont_to_alstruct;
		pos_insert->data = data;
	}

	int   cont_size(void* cont)
	{
		AL *from_cont_to_alstruct;
		int razm_cont = 0;

		from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
		from_cont_to_alstruct = (AL*)cont;
	
		while(from_cont_to_alstruct->Next)
		{
			from_cont_to_alstruct = from_cont_to_alstruct->Next;
			razm_cont++;
		}
	
		return razm_cont;
	}


	void* cont_get(void* cont, int pos)
	{
		AL *from_cont_to_alstruct;
		void* insert_data;

		from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
		from_cont_to_alstruct = (AL*)cont;

		while(((from_cont_to_alstruct->count)!=pos) || (from_cont_to_alstruct->Next))
		{
			from_cont_to_alstruct = from_cont_to_alstruct->Next;
		}

		insert_data = from_cont_to_alstruct->data;
		
		return insert_data;
	}


	void* cont_replace(void* cont, int pos, void* data)
	{
		AL *from_cont_to_alstruct;
		void *lost_data;

		from_cont_to_alstruct = (AL*)malloc(sizeof(AL));

		while ( ((from_cont_to_alstruct->count)!=pos) || (from_cont_to_alstruct->Next))
		{
			from_cont_to_alstruct = from_cont_to_alstruct->Next;	
		}

		lost_data = from_cont_to_alstruct->data;
		from_cont_to_alstruct->data = data;
		return lost_data;
	}


	void* cont_remove(void* cont, int pos)
	{
		AL *from_cont_to_alstruct;
		AL *vrem_xran;
		void *lost_data;
	
		from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
		vrem_xran = (AL*)malloc(sizeof(AL));
		from_cont_to_alstruct = (AL*)cont; 
	
		while ( ((from_cont_to_alstruct->count)!=pos) || (from_cont_to_alstruct->Next))
		{
			from_cont_to_alstruct = from_cont_to_alstruct->Next;	
		}
		lost_data = from_cont_to_alstruct->data;
		from_cont_to_alstruct->Prev->Next = from_cont_to_alstruct->Next;
		from_cont_to_alstruct->Next->Prev = from_cont_to_alstruct->Prev;
		from_cont_to_alstruct->Next = NULL;
		from_cont_to_alstruct->Prev = NULL;
		free(from_cont_to_alstruct);
		
		return (void*)vrem_xran;
}

	void  cont_foreach(void* cont/*, cont_handle*/)
	{
		AL *from_cont_to_alstruct;

		from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
		from_cont_to_alstruct = (AL*)cont;

		while(from_cont_to_alstruct->Next)
		{
			//cont_handle(from_cont_to_alstruct);
			from_cont_to_alstruct = from_cont_to_alstruct->Next;
		}
	}	


	void  cont_foreach_reverse(void* cont/*, cont_handle*/)
	{
		AL *from_cont_to_alstruct;

		from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
		from_cont_to_alstruct = (AL*)cont;

		while(from_cont_to_alstruct->Next)
		{
			from_cont_to_alstruct = from_cont_to_alstruct->Next;
		}

		while(from_cont_to_alstruct->Prev)
		{
			//	cont_handle(from_cont_to_alstructr); 
			from_cont_to_alstruct = from_cont_to_alstruct->Prev;
		}
	}


	void  cont_release(void* cont)
	{
		AL *from_cont_to_alstruct;

		from_cont_to_alstruct = (AL*)malloc(sizeof(AL));
		from_cont_to_alstruct = (AL*)cont;

		while(from_cont_to_alstruct->Next!=NULL)
		{
			from_cont_to_alstruct = from_cont_to_alstruct->Next;
		}

		while(from_cont_to_alstruct->Prev!=NULL)
		{
			from_cont_to_alstruct = from_cont_to_alstruct->Prev;
			free(from_cont_to_alstruct);
		}
	}

//#endif LIST

Test.cpp:

#include <stdio.h>
#include <stdlib.h>
#include "container.h"

int main()
{
	int *count;
	int count_two;
	void* cont;
	cont = cont_allocate();

	count = (int*)malloc(sizeof(int*)*100);

	for (count_two = 0; count_two <= 10; count_two +=1)
	{
		count[count_two] = count_two;
	}

	for (count_two = 0; count_two <= 10; count_two +=1)
	{
		cont_add(cont, &count[count_two]);
		printf("%d", cont->count);
	}
	cont_foreach(cont);
	cont_release(cont);
	return 0;	
}

Выложил все сразу, но на этот раз речь идет о LinkedList. Прошу помочь, время сдачи пджимает, а знания буксуют...стараюсь как могу, но без компетентной помощи загнусь....

[volvo]

"Ну-с, приступим..." (С) "Напарник"

Если ты вот тут:

int main()
    for (count_two = 0; count_two <= 10; count_two +=1)
    {
        cont_add(cont, &count[count_two]);
        printf("%d", ((AL*)cont)->count); // <--- у меня действительно компилируется только так...
    }

хотел распечатывать текущее число элементов в контейнере, то ты ошибся - здесь будет печататься count только для первого элемента контейнера, а это - всегда 0...

Это первое...
Второе... Я тебе еще в 5-ом посте написал, что такая конструкция:

    void* cont_replace(void* cont, int pos, void* data)
    {
        AL *from_cont_to_alstruct;
        void *lost_data;

        from_cont_to_alstruct = (AL*)malloc(sizeof(AL)); // <--- Вот тут ...

        while ( ((from_cont_to_alstruct->count)!=pos) || (from_cont_to_alstruct->Next))
        {
            from_cont_to_alstruct = from_cont_to_alstruct->Next;
        }
    ...

... приводит к утечким памяти. Зачем ты опять так делаешь malloc? Я же в седьмом посте написал, что надо сделать... Так делай это, а не создавай утечки...

Теперь - о том, почему у тебя

в лучем случае программа запускается демонстрирует пустой экран и закрывается -в худшев уходит в ссылку на ошибку в какоам - то закрытом сишном файле....

- а что ты хотел, мой компилятор говорит, что стек разрушается.

Я поправил файлы, у меня (GCC) они компилируются и работают, но проверял только ДО cont_foreach() включительно!!!, до cont_release() еще не дошел... Посмотри, что я изменил для того, чтобы работала передаваемая в cont_foreach() функция print_data() ...

[Neonig]

Сэнкс что взялся мне помочь, надеялся что следующим впросом разберём Аррай (ну если вдруг я и его косячно сделал), но не тут то было при компиляции линкдлист выдает две ошибки

1>Test.obj : error LNK2005: "struct ArrayList * cont" (?cont@@3PAUArrayList@@A) already defined in LinkedList.obj
1>C:\Users\VBproffi\Documents\Visual Studio 2008\Projects\WindowsApplication3\kont\Debug\kont.exe : fatal error LNK1169: one or more multiply defined symbols found
1>Build log was saved at "file://c:\Users\VBproffi\Documents\Visual Studio 2008\Projects\WindowsApplication3\kont\kont\Debug\BuildLog.htm"

Т.к ни на какие строчки не показывает я вообще без понятия что делать и что исправлять....

[volvo]

Я предупредил, что у меня не MSVS, из за таких вот глюков я ее и не люблю (там где нормальный компилятор справляется "на ура", VS приходится все разжевывать)...

Проблема - в том, что переменная cont описывается в header файле, который подключается более чем в одном *.C, из-за чего линкер считает это повторным объявлением... Сделай переменную статической:

#ifndef LINKEDLIST_H
#define LINKEDLIST_H

    typedef struct ArrayList{
        struct ArrayList *Prev;
        struct ArrayList *Next;
        void* data;
        int count;
    } AL;

    static AL *cont; // <---
    static int count = 0;

#endif

по идее это должно решить проблему для VS, поскольку на count у тебя линкер не ругается.

Сообщение отредактировано: volvo - 30.09.2007 12:01