Operacje insert, remove, dlasze refaktoryzacje

program.cpp

@@ -67,6 +67,14 @@ int main() {
     std::cout << "w: " << w << '\n';
     std::cout << "z: " << z << '\n';
     std::cout << "v: " << v << '\n';
+    std::cout << '\n';
+
+    w.remove(1);
+    std::cout << "w: " << w << '\n';
+    w.insert(5, 5555);
+    w.insert(5, 5665);
+    w.insert(10, 101010);
+    std::cout << "w: " << w << '\n';
 
 
     std::cout << "Koniec programu\n";

wektor.cpp

@@ -41,6 +41,24 @@ void Wektor::kopiuj_elementy(const Wektor &zrodlowy) {
     kopiuj_zawartosc_tablicy(t, zrodlowy.t, liczba_elementow);
 }
 
+void Wektor::prawidlowy_indeks(TypIndeksu idx) const {
+    if(idx < 0 || idx >= liczba_elementow) {
+        throw IndexOutOfBounds{idx, liczba_elementow};
+    }
+}
+
+void Wektor::ensure_size() {
+    if(liczba_elementow < rozmiar_tablicy) {
+        return; // wszystko OK
+    }
+    // przerzuć elementy do większej tablicy
+    rozmiar_tablicy = 2*rozmiar_tablicy;
+    TypWartosci *nt = new TypWartosci[rozmiar_tablicy];
+    kopiuj_zawartosc_tablicy(nt, t, liczba_elementow);
+    delete[] t;
+    t = nt; // do t wpisujemy wskaźnik do nowe tablicy
+}
+
 
 const TypIndeksu startowy_rozmiar_tablicy = 8;
 
@@ -75,30 +93,37 @@ TypIndeksu Wektor::size() const {
     return liczba_elementow;
 }
 
+TypWartosci Wektor::operator[](TypIndeksu idx) const {
+    prawidlowy_indeks(idx);
+    return t[idx];
+}
+
+TypWartosci& Wektor::operator[](TypIndeksu idx) {
+    prawidlowy_indeks(idx);
+    return t[idx];
+}
+
 void Wektor::push_back(TypWartosci e) {
-    if(liczba_elementow == rozmiar_tablicy) {
-        // przerzuć elementy do większej tablicy
-        rozmiar_tablicy = 2*rozmiar_tablicy;
-        TypWartosci *nt = new TypWartosci[rozmiar_tablicy];
-        kopiuj_zawartosc_tablicy(nt, t, liczba_elementow);
-        delete[] t;
-        t = nt; // do t wpisujemy wskaźnik do nowe tablicy
-    }
+    ensure_size();
     t[liczba_elementow++] = e;
 }
 
-TypWartosci Wektor::operator[](TypIndeksu idx) const {
-    if(idx < 0 || idx >= liczba_elementow) {
-        throw IndexOutOfBounds{idx, liczba_elementow};
+void Wektor::insert(TypIndeksu idx, TypWartosci e) {
+    prawidlowy_indeks(idx-1);
+    ensure_size();
+    for(TypIndeksu i = liczba_elementow; i > idx; i--) {
+        t[i] = t[i-1];
     }
-    return t[idx];
+    t[idx] = e;
+    liczba_elementow++;
 }
 
-TypWartosci& Wektor::operator[](TypIndeksu idx) {
-    if(idx < 0 || idx >= liczba_elementow) {
-        throw IndexOutOfBounds{idx, liczba_elementow};
+void Wektor::remove(TypIndeksu idx) {
+    prawidlowy_indeks(idx);
+    liczba_elementow--;
+    for(TypIndeksu i = idx; i < liczba_elementow; i++) {
+        t[i] = t[i+1];
     }
-    return t[idx];
 }
 
 std::ostream&  operator<<(std::ostream& out, const Wektor& w) {

wektor.h

@@ -32,6 +32,18 @@ class Wektor {
     /** Z podanego wektora kopiuje elementy do wektora bieżącego. */
     void kopiuj_elementy(const Wektor &zrodlowy);
 
+    /** Upewnia się, że tablicy jest miejsce na jeden dodatkowy element,
+     *  a gdyby nie było, to powiększa wewnętrzną tablicę.
+     *  Stosujemy technikę dwukrotnego powiększania tablicy, co daje dobra złożonośc zamortyzowaną.
+     */
+    void ensure_size();
+
+    /** Sprawdza, czy indeks mieści się w zakresie.
+     *  Gdyby się nie mieścił, to wyrzuca wyjątek.
+     *  (jest to forma asercji)
+     */
+    void prawidlowy_indeks(TypIndeksu idx) const;
+
 public:
     Wektor();
 
@@ -43,15 +55,25 @@ public:
 
     TypIndeksu size() const;
 
-    /** Dodanie nowego elementu na końcu. */
-    void push_back(TypWartosci e);
-
     /** Odczyt wartości spod podanej pozycji. */
     TypWartosci operator[](TypIndeksu idx) const;
 
     /** Dostęp do wartości na podanej pozycji. Tutaj wynikiem jest referencja jako tzw. "lvalue". */
     TypWartosci& operator[](TypIndeksu idx);
 
+    /** Dodanie nowego elementu na końcu. */
+    void push_back(TypWartosci e);
+
+    /** Na pozycję pos wstawia nową wartość w taki sposób,
+     *  że dotychczasowe elementy od tego miejsca są przesuwane o jedną pozycję w prawo.
+     */
+    void insert(TypIndeksu idx, TypWartosci e);
+
+    /** Usuwa wartoć z podanego indeksu,
+     *  a powstałą "dziurę" łata przesuwając elementy w lewo.
+     */
+    void remove(TypIndeksu idx);
+
     friend std::ostream& operator<<(std::ostream&, const Wektor&);
 };