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;
}

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;
}

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;
}

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

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

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

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];
}

#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

#ifndef ARRAYLIST_H
#define AARAYLIST_H

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

	AR *cont;

#endif

#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 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

#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

#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

#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;	
}

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

    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;
        }
    ...

#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