[c++]Seznam

#ifndef _SEZNAM_H_
#define _SEZNAM_H_

template <class T>
class seznam {
protected:
    struct element{
        int vrednost;
        element* k_nasl;
        //konstruktor
        element(const T& vred, element* kazalec) {
            vrednost = vred;
            kazalec = k_nasl;
        }
    };
    
    element* k_zacetek;
    int velikost_seznama;
    
public:
	seznam();
	seznam(const seznam& s);
	~seznam();

	void vstavi(int indeks, const T& vred);
	void vrini(int indeks, const T& vred);
	void brisi(int indeks);
	T vrni(int indeks) const;
	int isci(const T& vred) const;
	bool prazen() const;
	int velikost() const;
};

template <class T>
seznam<T>::seznam() {
    k_zacetek = NULL;
    velikost_seznama = 0;
}

template <class T>
seznam<T>::seznam(const seznam& s) {
    if (s.velikost() == 0) {
       k_zacetek = NULL;
       velikost_seznama = 0;
       return;
    }
    else
       velikost_seznama = s.velikost();
    
    k_zacetek = new element(s.k_zacetek->vrednost, NULL);
    element* k = s.k_zacetek;
    element* k1 = s.k_zacetek->s.k_nasl;
    while(k != NULL) {
            k_zacetek->k_nasl = new element(k1, k_zacetek->k_nasl);
            k1 = k1->s.k_nasl;        
    }
}

template <class T>
seznam<T>::~seznam() {
     element* k = k_zacetek;
     while(k != NULL) {
             k = k_zacetek->k_nasl;
             delete k_zacetek;
             k_zacetek = k;
     }
}

template <class T>
void seznam<T>::vstavi(int indeks, const T& vred) {
     int i = 0;
     element* k = k_zacetek; 
     while (indeks != i) {
           k = k->k_nasl;
           i++;
     }
     k->vrednost = vred;
}

template <class T>
void seznam<T>::vrini(int indeks, const T& vred) {
     int i = 0;
     element* k = k_zacetek;
     
     if ( k_zacetek == NULL ) {
        cout << "Seznam je bil prazen, zato ustvarjen nov (prvi) element z vrednostjo." << endl;
        k_zacetek = new element(vred, NULL);
     }
     
     else if (indeks == 0 && velikost_seznama > 0) {
          cout << "Dodano na zacetek seznama" << endl;
          k = new element(vred, k);     
     }
     
     else if (indeks > velikost_seznama) {
          while (k->k_nasl != NULL)
                k = k->k_nasl;
          k->k_nasl = new element(vred, NULL);     
     }
     
     else {
          while ( i != (indeks-1)){
			k = k->k_nasl;
			i++;
          }
		  k->k_nasl = new element(vred,k->k_nasl);
	}
	velikost_seznama = velikost_seznama + 1;
}

template <class T>
void seznam<T>::brisi(int indeks) {
     element* k = k_zacetek;
     int i = 0;
     
     if (indeks > velikost_seznama || indeks < 0)
        cout << "Tak indeks ne obstaja." << endl;
        
     else if (indeks == 0) {
          element* k_novi_zacetek = k_zacetek;
          delete k_zacetek;
          k_novi_zacetek = k_novi_zacetek->k_nasl;
     }
     
     else if (indeks == (velikost_seznama-1)) {
          while (indeks != i) {
                k = k->k_nasl;
                i++;
          }
          delete k;
     }
     
     else {
          while (indeks != i) {
           k = k->k_nasl;
           i++;     
          }
          element* k_novi = k;
          delete k;
          k_novi = k->k_nasl;
          velikost_seznama = velikost_seznama - 1;
     }
     velikost_seznama = velikost_seznama - 1;
}

template <class T>
T seznam<T>::vrni(int indeks) const {
  element* k = k_zacetek;
  int i = 0;
  while(indeks != i) {
          k = k->k_nasl;
          i++;     
  }
  return k->vrednost;
}

template <class T>
int seznam<T>::isci(const T& vred) const {
	element* k = k_zacetek;
	int i = 0;

	while(k != NULL) {
		if (k->vrednost == vred) {
            return i;
			continue;
        }
		k = k->k_nasl;
		i++;
	}
	return -1;
}

template <class T>
bool seznam<T>::prazen() const {
     element* k = k_zacetek;
     if (k == NULL)
        return true;
     else
         return false;
}

template <class T>
int seznam<T>::velikost() const {
    int i = 0;
    for (element* k = k_zacetek; k != NULL; k = k->k_nasl) 
        i++;
    return i;
}

#endif

template <class T>
int seznam<T>::isci(const T& vred) const {
	element* k = k_zacetek;
	int i = 0;

	while(k != NULL) {
		if (k->vrednost == vred) {
                        return i;
			continue;
        }
		k = k->k_nasl;
		i++;
	}
	return -1;
}

cout << mojSklad.vrh() << endl;

if (kljuc > k_zacetek->kljuc)