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

[Neonig]

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

!

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

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

[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. Прошу помочь, время сдачи пджимает, а знания буксуют...стараюсь как могу, но без компетентной помощи загнусь....