Implementacja listy dwu kierunkowej

Wita, implementuję listę dwu kierunkową, mam problem z dodawaniem nowych elementów, gdy je inicjuję ich wartość jest inna niż ją określę, moglibyście spojrzeć w mój kod i napisać mi gdzie jest błąd? Oto kod:

 template <typename typ>
class lista
{
	signed int identyfikator;
	class element
	{
	public:
		element *następny;
		element *poprzedni;
		typ wartość;
		int identyfikator;
	};
	element *pierwszy;
	element *ostatni;
	element *aktualny;
	element *obiekt;
public:
	lista()
	{
		identyfikator=1;
		obiekt=new element;
		pierwszy=obiekt;
		ostatni=obiekt;
		aktualny=obiekt;
		aktualny->wartość=0;
		aktualny->identyfikator=identyfikator;
	}	
	lista(typ wartość)
	{
		identyfikator=1;
		obiekt=new element;
		pierwszy=obiekt;
		ostatni=obiekt;
		aktualny=obiekt;
		aktualny->wartość=wartość;
		aktualny->identyfikator=identyfikator;
	}
	lista(int ilość, typ wartość)
	{
		identyfikator=1;
		obiekt=new element;
		pierwszy=obiekt;
		ostatni=obiekt;
		obiekt->identyfikator=identyfikator;
		aktualny=obiekt;
		obiekt->wartość=wartość;
		int obrót=1;
		while(obrót<ilość)
		{
			identyfikator++;
			obiekt=new element;
			obiekt->identyfikator=identyfikator;
			obiekt->wartość=wartość;
			obiekt->poprzedni=aktualny;
			aktualny->następny=obiekt;
			aktualny=obiekt;
			ostatni=obiekt;
			obrót++;
		}
	}
	lista(int ilość, typ *wartość)
	{
		identyfikator=1;
		obiekt=new element;
		pierwszy=obiekt;
		ostatni=obiekt;
		obiekt->identyfikator=identyfikator;
		aktualny=obiekt;
		obiekt->wartość=wartość[0];
		int obrót=1;
		while(obrót<ilość)
		{
			identyfikator++;
			obiekt=new element;
			obiekt->identyfikator=identyfikator;
			obiekt->wartość=wartość[obrót];
			obiekt->poprzedni=aktualny;
			aktualny->następny=obiekt;
			aktualny=obiekt;
			ostatni=obiekt;
			obrót++;
		}
	}
	~lista()
	{
		delete[] obiekt;
	}
	void wyświetlanie_listy()
	{
		aktualny=pierwszy;
		if(pierwszy==ostatni)
		{
			cout<<aktualny->wartość<<endl;
		}
		else
		{
			while(aktualny!=ostatni)
			{
				cout<<aktualny->wartość<<endl;
				aktualny=aktualny->następny;
			}
		}
	}
	typ wyświetlanie_elementu(int identyfikator)
	{
		aktualny=pierwszy;
		if(pierwszy==ostatni)
		{
			if(aktualny->identyfikator==identyfikator)
			{
				return aktualny->wartość;
			}
			else
			{
				return 0;
			}
		}
		else
		{
			while(aktualny!=ostatni)
			{
				if(identyfikator==aktualny->identyfikator)
				{
					return aktualny->wartość;
					break;
				}
				aktualny=aktualny->następny;
			}
		}
	}
	int wyświetlanie_indeksu(typ wartość)
	{
		aktualny=pierwszy;
		if(pierwszy==ostatni)
		{
			if(aktualny->wartość==wartość)
			{
				return aktualny->identyfikator;
			}
			else
			{
				return 0;
			}
		}
		else
		{
			while(aktualny!=ostatni)
			{
				if(wartość==aktualny->wartość)
				{
					return aktualny->identyfikator;
					break;
				}
				aktualny=aktualny->następny;
			}
			return 0;
		}
	}
	void edytuj_element(int identyfikator, typ wartość)
	{
		aktualny=pierwszy;
		if(pierwszy==ostatni)
		{
			if(aktualny->identyfikator==identyfikator)
			{
				aktualny->wartość=wartość;
			}
		}
		else
		{
			while(aktualny!=ostatni)
			{
				if(identyfikator==aktualny->identyfikator)
				{
					aktualny->wartość=wartość;
					break;
				}
				aktualny=aktualny->następny;
			}
		}
	}

	void dodaj_element(typ wartość)
	{
		
		obiekt=new element;
		aktualny=obiekt;
		ostatni->następny=obiekt;
		obiekt->poprzedni=ostatni;
		obiekt->identyfikator=ostatni->identyfikator+1;
		ostatni=obiekt;
		aktualny->wartość=wartość;
		aktualny=pierwszy;
	}
	void dodaj_element()
	{
		obiekt=new element;
		ostatni->następny=obiekt;
		obiekt->poprzedni=ostatni;
		obiekt->identyfikator=ostatni->identyfikator+1;
		ostatni=obiekt;
	}
	void sortowanie()
	{

	}
	void resortowanie()
	{

	}
};

Visual Studio 2012 akceptuje polskie znaki.

Początek:

template <typename typ> class lista
  {
   struct element
     {
      typ wartosc;
      int identyfikator;
      element *poprzedni,*nastepny;
      element(typ wartosc,int identyfikator,element *poprzedni,element *nastepny=0):wartosc(wartosc),identyfikator(identyfikator),poprzedni(poprzedni),nastepny(nastepny) {}
     };
   element *pierwszy,*ostatni; // żadnych więcej składowych
   int identyfikator;
   public:
   lista():pierwszy(0),ostatni(),identyfikator(1) {} // żadnych więcej konstruktorów
   dodaj_element(typ wartosc) { ostatni=(ostatni?ostatni->nastepny:pierwszy)=new element(wartosc,++identyfikator,ostatni); } // żadnych innych dodawań
  };

Resztę spróbuj zrobić sam.

Trudno ten kod skomentować ale po co ci tyle wskaźników w klasie lista ? Do obsługi tzw. double-linked-list wystarczy ci pointer na pierwszy i ostatni element. Ponadto lista domyślnie powinna być pusta, więc nie wiem jaki sens ma tworzenie elementu o wartości 0 w konstruktorze. Listę najprościej pokazać tak:

element * ptr = pierwszy;
while(ptr != NULL){
  std::cout << ptr->wartosc << '\n';
  ptr = ptr->nastepny;
}

Po co u Ciebie inne wynalazki po prostu nie mam pojęcia.

PS. Plus za super-gigantyczne wcięcia w kodzie - czy wy tego nie widzicie czy o co chodzi ?

Pozdrawiam.

Witam koledzy poprawiłem błędy, sprawdźcie czy ta lista nie wysypie się na jakiś przypadkach testowych.

 template <typename typ>
class lista_dwukierunkowa
{
private:
	int identyfikator;
	class element
	{
	public:
		element *następny;
		element *poprzedni;
		int identyfikator;
		typ wartość;
		element(int parametr_identyfikator, typ parametr_wartość)
		{
			identyfikator=parametr_identyfikator;
			wartość=parametr_wartość;
		}
	};
	element *obiekt;
	element *aktualny;
	element *pierwszy;
public:
	void wyświetl_zawartość()
	{
		if(sizeof(typ)==sizeof(char))
		{
			aktualny=pierwszy;
			while(!aktualny->następny==NULL)
			{
				cout<<aktualny->wartość;
				aktualny=aktualny->następny;
			}
			cout<<aktualny->wartość;
		}
		else
		{
			aktualny=pierwszy;
			while(!aktualny->następny==NULL)
			{
				cout<<aktualny->wartość<<endl;
				aktualny=aktualny->następny;
			}
			cout<<aktualny->wartość<<endl;
		}
	}
	typ wyświetl_element(int identyfikator)
	{
		aktualny=pierwszy;
		while(aktualny->następny!=NULL)
		{
			if(aktualny->identyfikator==identyfikator)
			{
				return aktualny->wartość;
				break;
			}
			aktualny=aktualny->następny;
		}
		if(aktualny->identyfikator==identyfikator)
		{
			return aktualny->wartość;
		}
		return 0;
	}
	int wyświetl_identyfikator(typ wartość)
	{
		aktualny=pierwszy;
		while(aktualny->następny!=NULL)
		{
			if(aktualny->wartość==wartość)
			{
				return aktualny->identyfikator;
				break;
			}
			aktualny=aktualny->następny;
		}
		if(aktualny->wartość==wartość)
		{
			return aktualny->identyfikator;
		}
		return 0;
	}
	void dodaj_element(typ wartość)
	{
		if(pierwszy==NULL)
		{
			obiekt=new element(identyfikator, wartość);
			pierwszy=obiekt;
		}
		else
		{
			aktualny=pierwszy;
			while(!aktualny->następny==NULL)
			{
				aktualny=aktualny->następny;
			}
			identyfikator++;
			obiekt=new element(identyfikator, wartość);
			aktualny->następny=obiekt;
			obiekt->następny=NULL;
			obiekt->poprzedni=aktualny;
		}
	}
	void usuń_element(int identyfikator)
	{
		aktualny=pierwszy;
		if(aktualny->identyfikator==identyfikator)
		{			
			pierwszy=aktualny->następny;
			pierwszy->poprzedni=NULL;
		}
		else
		{
			while(aktualny->następny!=NULL)
			{
				if(aktualny->identyfikator==identyfikator)
				{
					aktualny->następny->poprzedni=aktualny->poprzedni;
					aktualny->poprzedni->następny=aktualny->następny;
					aktualny=aktualny->następny;
					break;
				}
				aktualny=aktualny->następny;
			}
			if(aktualny->identyfikator==identyfikator)
			{
				aktualny->poprzedni->następny=NULL;
			}
		}
	}
	void sortuj_rosnąco()
	{
		aktualny=pierwszy;
		while(true)
		{
			if(aktualny==NULL)
			{
				break;
			}
			else
			{
				if(aktualny->poprzedni!=NULL && aktualny->wartość < aktualny->poprzedni->wartość)
				{
					typ tmp=aktualny->wartość;
					aktualny->wartość=aktualny->poprzedni->wartość;
					aktualny->poprzedni->wartość=tmp;
					aktualny=aktualny->poprzedni;
					continue;
				}
				aktualny=aktualny->następny;
			}
		}
	}
	void sortuj_malejąco()
	{
		aktualny=pierwszy;
		while(true)
		{
			if(aktualny==NULL)
			{
				break;
			}
			else
			{
				if(aktualny->poprzedni!=NULL && aktualny->wartość > aktualny->poprzedni->wartość)
				{
					typ tmp=aktualny->wartość;
					aktualny->wartość=aktualny->poprzedni->wartość;
					aktualny->poprzedni->wartość=tmp;
					aktualny=aktualny->poprzedni;
					continue;
				}
				aktualny=aktualny->następny;
			}
		}
	}
	lista_dwukierunkowa(typ wartość)
	{
		identyfikator=1;
		obiekt=new element(identyfikator,wartość);
		pierwszy=obiekt;
		obiekt->następny=NULL;
		obiekt->poprzedni=NULL;
	}
	lista_dwukierunkowa()
	{
		identyfikator=1;
		pierwszy=NULL;
	}
	~lista_dwukierunkowa()
	{
		delete[] obiekt;
	}
};

Brakuje konstruktora kopiującego. Ewentualnie możesz kopiowania listy zabronić, czyniąc go prywatnym.

Iż Polacy nie gęsi, iż swój język mają...
Wolę patriotyczne podejście :)

Owszem, ale ja korzystam z Visuala więc nie mam takiego problemu.

adam vip napisał(a):

Owszem, ale ja korzystam z Visuala więc nie mam takiego problemu.

A potem wyobraź sobie, że szukasz w necie jakiegoś przykładu, i widzisz coś takiego:

template <typename 型>
class リスト
  {
   struct 要素
	 {
	  型 値;
	  int 識別名;
	  要素 *先, *次;
	  要素(型 値,int 識別名,要素 *先,要素 *次=0):値(値),識別名(識別名),先(先),次(次) {}
	 };
   要素 *始,*最後;
   int 識別名;
   public:
   リスト():始(0),最後(),識別名(1) {}
   void 要素を追加(型 値) { 最後=(最後?最後->次:始)=new 要素(値,++識別名,最後); }
  };

Na ile zrozumiały ci się kod wydaje? A to przecież to samo, co @_13th_Dragon podał wyżej...