Usuwanie elementu z tablicy

Question

Witam,

Napisałem funkcję dodającą obiekt do obiektu Planeta. 

void planeta::dodaj_zwierze(zwierze zwierze_){
    ilosc_zwierzat++;
    zwierze* pom = new zwierze[ilosc_zwierzat];
    for (int i = 0; i<ilosc_zwierzat - 1; i++){
        pom[i] = zwierzeta_[i];
    }

    pom[ilosc_zwierzat-1] = zwierze_;

    if(zwierzeta_ != 0)
        delete[] zwierzeta_;

    zwierzeta_ = pom;
}

Niestety nie wiem jak sobie poradzić z funkcją, która będzie usuwała i-ty z tej tablicy.

 

Comments

A dlaczego nie std::vector, tylko robótki ręczne?

Answer 1

Musisz napisać podobną pętlę. Jeśli indeks z pod którego chcesz usunąc to k (licząc od 0) to podczas przepisywania do nowej tablicy musisz napisać if'a który w momencie gdy trafi na k nie przepisze go i ponadto gdzies zapamieta że od tej pory powinien do i-tej komorki wpisywac i+1 ze starej tablicy (bo jeden element pomienlismy):

if(i == k) 
{
	przesun =1;
	continue;
}
pom[i] = zwierzeta_[i + przesun];

oczywiscie przesun musisz zainicjować na 0 przed pętlą

 

Answer 2

W swoim śmietniku znalazłem przykład który pasuje do Twojego pytania. To przysłowiowe jedzenie zupy widelcem. Da się ale w jakim celu? Stosuj std::vector bo podejście w przykładzie który widzisz jest "samogwałtem programistycznym" w dzisiejszych czasach.

Widmo Grębosza krąży.. :/

#include <iostream>
#include <cstddef>

struct Container {
    Container(): current_size(), data(NULL) {}
    void add_value(int value) {
        // Nowa tablica
        // FIXME: A co jak się nie powiedzie?
        int * new_table = new int[current_size + 1];
        // Przepisywanie starych wartości
        for(std::size_t i = 0; i < current_size; ++i) {
            new_table[i] = data[i];
        }
        // Nowa wartość na końcu
        new_table[current_size] = value;

        delete [] data;
        ++current_size;
        data = new_table;
    }
    void remove_value_from_left(int value) {
        // Z pustej tablicy nie ma sensu...
        if(!current_size) {
            return;
        }
        for(std::size_t i = 0; i < current_size; ++i) {
            if(data[i] == value) { // Znaleziono element...
                // FIXME: A co jak się nie powiedzie?
                int * new_table = new int[current_size - 1];
                // Przepisywanie wartości przed... 
                for(std::size_t j = 0; j < i; ++j) { 
                    new_table[j] = data[j];
                }
                // Przepisywanie wartości po
                for(std::size_t j = i; j < current_size; ++j) {
                    new_table[j - 1] = data[j];
                }
                // Przypisanie nowej tablicy i dekrementacja wielkości
                delete [] data;
                data = new_table;
                --current_size;
                // Znaleziono 1 element, przepisano więc wyskakuję z pętli.
                break;
            }
        }
    }
    std::size_t size() const {
        return current_size;
    }
    // Nie chciałem robić operator[] bo nie wiem czy znasz.. 
    const int * get_table() const {
        return data;
    }
    ~Container() {
        delete [] data;
    }
private:
    int *data;
    std::size_t current_size;
};

int main() {
    Container container;
    container.add_value(100);
    container.add_value(200);
    container.add_value(300);
    std::cout << "Size before remove: " << container.size() << '\n';
    container.remove_value_from_left(200);
    std::cout << "Size after remove: " << container.size() << '\n';
    std::cout << "Container values:\n";
    for(std::size_t i = 0; i < container.size(); ++i) {
        std::cout << container.get_table()[i] << ' ';
    }
    std::cout << '\n';
}

Zażaleń typu "co można poprawić" nie przyjmuję. Tu można poprawić wszystko nie stosując tablic.

Jeśli będziesz stosował std::vector, pamiętaj o idiomie: Erase-remove idiom