[C++] Dynamische array, een blijvende variable size *

[Verwijderd]

ik ben bezig aan een mp3 programma en daarin heb ik 2 objecten. (ja wel wat meer, maar die boeien nu even niet.)

Hoofdlijst en playlijst
de hoofdlijst bevat alle gegevens over alle mp3's op het systeem.

playlijst bevat een index lijst die verwijst naar de hoofdlijst.
dit wou ik doen met behulp van een dynamische array.

enkel ik vind de manier hoe ik het nu doe wel erg omslachtig.
zou het meschien mogelijk zijn om de lijst onmiddelijk te vergrote zonder dat ik hem eerst moet deleten en weer aanmaken?

de vraag is dus, hoe zou ik de functie om een nummer aan de index (mp3_index) toe te voegen zonder dat ik daar die lelijke constructie voor hoef te gebruiken.
-tmp lijst defineren die 1 veld groter is dan huidige lijst.
-huidige lijst copieeren naar tmp lijst.
-huidige lijst verwijderen en opnieuw aanmaken met 1 veld meer.
-tmp lijst terug copieeren naar huidige lijst.

C++:

class play_lijst{
public:
    play_lijst(){
    }   
    
    void create_list(int i[]){
        mp3_index = new int[sizeof(i)];
        max_index = sizeof(i);
        int j=0;
        while (sizeof(i)){
            mp3_index[j] = i[j];
            j++;
        }
    }
    
    void add_song(int i){
        int j=0;
        int *tmp_index;
        tmp_index = new int[max_index+1];   
        while (j <= max_index) {
            tmp_index[j] = mp3_index[j];
            j++;
        }
        tmp_index[max_index+1] = i;
        delete mp3_index;
        max_index++;
        mp3_index = new int[max_index];
        j=0;
        while (j <= max_index) {
            mp3_index[j] = tmp_index[j];
            j++;
        }
    }
    
private:
    int *mp3_index;
    int index;
    int max_index;
};

-edit-
spelling en vraagstelling wat duidelijker opgeschreven. (hoop ik)

[ Voor 21% gewijzigd door Verwijderd op 23-06-2003 00:11 ]

[Verwijderd]

Ik heb je bericht 3x doorgelezen maar ik snap er echt niets van. Misschien moet je je vraag eens duidelijk formuleren en zeggen waar het fout gaat.
Volgens mij zijn die pointers ook geheel overbodig en kan je dat wel op een andere manier oplossen. Maar nogmaals ik snap je bedoelingen niet.

_{En een cursus nederlands kan ook geen kwaad.}

[curry684]

_{Dat heet 'dynamische' niet 'dynamiese'. Topictitle fixed... Tevens mag je wel wat meer op je spelling letten, 'omslagtig' en 'meschien' staan ook niet op www.vandale.nl}

[MSalters]

Met std::vector zou die class 10 regels oid zijn. std::vector<>::resize( ) is precies wat de TS wil.

[Verwijderd]

heb even lopen zoeken naar hoe vectors werken.
en dat is het antwoord denk ik.
dan kan ik simpel met
mp3_index.push_back(i);
mp3 index nummers toevoegen

[Verwijderd]

realloc

[Verwijderd]

omdat het wel zo aardig is om te laten zien hoe ik het heb gefixed hier nog even de veranderingen in de code.

(let even niet op get_song daar moet nog wat worden doorgevoerd.
ik ben namelijk ook al bezig om van array of char naar string te verhuizen

C++:

class play_lijst{
public:
    play_lijst(){
    }   
    
    void create_list(vector <int>  i){
        max_index = i.size();
        int j=0;
        while (j <= i.size()){
                mp3_index.push_back(i[j]);
            j++;
        }
    }
    
    void add_song(int i){
        mp3_index.push_back(i);
        max_index++;
    }
    
    void get_songlist(){
        int j=0;
        while (j <= max_index){
            cout <<  j << ':' << mp3_index[j]<< '\n';
            j++;
        }
    }
    
    string get_song(int i){
        string tmp;
        //tmp = hoofd_lijst.get_record(i);
        return tmp;
    }
private:
    vector <int> mp3_index;
    //int *mp3_index;
    int index;
    int max_index;
};

[rollebol]

Hoewel de STL het met vector mooi voor je heeft opgelost, kan het voor het begrip geen kwaad om eens te kijken hoe een linked list (DLL) werkt. Dit kan je gebruiken als je even geen STL bij de hand hebt (zoals in C):

Maak een struct (of class) bestaande uit een element 'next' en een element 'data'. 'data' wijst naar je eigenlijke struct die je in de lijst wil opnemen, en 'next' wijst naar het volgende element in de lijst. Door de lijst af te gaan tot dat next null is loop je langs alle elementen van de lijst.

Je kan er een double linked list van maken door naast next ook previous (of zo) bij te houden. Je hebt dan niet alle administratieve overhead van jouw array met pointers en je kan theoretisch oneindig lange lijsten maken.

[Verwijderd]

daar had ik ook al wat over gelezen rollebol, maar dat zou niet werkbaar zijn.
want het moet mogelijk zijn om van 1 op eens naar 854 te gaan en dan weer 3 ofzo.
met zo'n lijst zou het dan zijn dat ik steeds de complete lijst moet doorwerken tot ik het goede index nummer heb gevonden. (als ik het goed had begrepen iig)

alhoewel dat met tegenwoordige computers natuurlijk milisecode werk is, vond ik het ergenst toch niet netjes.

of zie ik het dan verkeerd?

[Soultaker]

Doe ook eens wat research naar het by-reference passen van argumenten (en const-ness, als je dan toch bezig bent), want die create_list-methode lijkt echt nergens op. Zoek ook eens uit wat een constructor doet (want eigenlijk wil je volgens mij die definieren, en niet een methode als create_list). Verder is mij compleet onduidelijk wat de klasseinvarianten zijn; wat doen die index en max_index als member variables in je klasse?

Laat ik mijn tips samenvatten: als je dit project gebruikt om te leren programmeren in C++, dan is daar niets mis mee, maar probeer alsjeblieft nog niet er een uitgebreide/ingewikkelde applicatie van te maken, want dat gaat op deze manier geheid mis.

Verwijderd schreef op 23 June 2003 @ 01:39:
alhoewel dat met tegenwoordige computers natuurlijk milisecode werk is, vond ik het ergenst toch niet netjes.

of zie ik het dan verkeerd?

Je ziet het goed; lineaire toegangstijd blijft lineaire toegangstijd, terwijl de vector als dynamische array je een constante toegangstijd geeft. Dat is veel beter, als je de inhoud ervan zelden wilt veranderen en vaak wilt benaderen op willekeurige punten.

[ Voor 28% gewijzigd door Soultaker op 23-06-2003 01:45 ]

[Verwijderd]

het is niet zozeer dat ik C++ leer door dit project te maken alswell dat ik project maak en daarvoor C++ leer.

je hebt gelijk over die create_list methode, die kan ook eigenlijk wel in de constructor.

index is bedoelt als nummer wat bij houd bij welke mp3 hij nu is.
max_index is het aantal mp3's wat in de lijst staat. (eigenlijk wel een beetje overbodig mp3_index.size() zou hetzelvde geven. )

het zit zeg maar zo.
ik heb het object mp3 deze bevat informatie over 1 mp3, (waar die staat en de ID3 tag via ID3lib)
Er is een object hoofd_lijst wat de complete lijst is van mp3's.

En dan dit object playlijst wat een compilatie is van de hoofd_lijst via search functies die binnen het object player komen.
zo kun je meerdere playlists hebben terwijl hij zijn mp3 informatie nogsteeds maar uit 1 hoofdlijst hoeft te halen.
en nou zal het vast zijn dat zo'n hoofdlijst niet 100% nodig is omdat ik het ook met pointers zou kunnen doen die naar die mp3 objecten kunnen verwijzen. maar ik vind dit een overzichtelijkere opzet die ik zelf beter kan begrijpen/beheren.

en dan nog het object player dat mp3'tjes speelt die hij krijgt vanuit de geselecteerde playlist ook stuurt hij informatie door naar het nog niet bestaande LCD display aansturings object en krijgt zijn commando's vanuit het nog niet geschreven invoer object. (invoer zal gaan via een soortje autoradio interface)

[ Voor 8% gewijzigd door Verwijderd op 23-06-2003 02:17 ]

[.oisyn]

rollebol schreef op 23 June 2003 @ 01:26:
Hoewel de STL het met vector mooi voor je heeft opgelost, kan het voor het begrip geen kwaad om eens te kijken hoe een linked list (DLL) werkt.

Een Dynamic Link Library heeft weinig met een linked list te maken

[Glimi]

Doubly Linked List bedoelt rollebol denk ik oisyn

[.oisyn]

uiteraard, vandaar de , maar dat is niet gebruikelijk als je het over een DLL hebt

[Schmoove]

De klasse CArray is dynamisch
Volgens mij is CArray een MFC klasse... weet niet zeker, maar je moet maar eens in de MSDN library kijken.
Anders zoals boven beschreven kun je altijd een linked list pakken, is een mooie oplossing. Ook een vector is hier heel geschikt voor, zeker omdat deze heel makkelijk te gebruiken is.

[MSalters]

CArray is eeeevil. En't werkt ook nog niet eens onder Linux. 't Is inderdaad MFC _{ook wel bekend als My First Coding}. Het is wel een array klasse - voor dit probleem is een list de verkeerde oplossing. De container moet overeenkomen met het meest voorkomende soort access. Hier is het simpelweg lineair, daarvoor is vector optimaal.

[ Voor 3% gewijzigd door MSalters op 23-06-2003 21:31 ]

[MSalters]

Verwijderd schreef op 23 juni 2003 @ 01:17:
omdat het wel zo aardig is om te laten zien hoe ik het heb gefixed hier nog even de veranderingen in de code.

(let even niet op get_song daar moet nog wat worden doorgevoerd.
ik ben namelijk ook al bezig om van array of char naar string te verhuizen

C++:

class play_lijst{
public:
    play_lijst(){
    }   
    
    void create_list(vector <int>  i){
        max_index = i.size();
        int j=0;
        while (j <= i.size()){
                mp3_index.push_back(i[j]);
            j++;
        }
    }
    
    void add_song(int i){
        mp3_index.push_back(i);
        max_index++;
    }
    
    void get_songlist(){
        int j=0;
        while (j <= max_index){
            cout <<  j << ':' << mp3_index[j]<< '\n';
            j++;
        }
    }
    
    string get_song(int i){
        string tmp;
        //tmp = hoofd_lijst.get_record(i);
        return tmp;
    }
private:
    vector <int> mp3_index;
    //int *mp3_index;
    int index;
    int max_index;
};

vector is een fatsoenlijk object, dus met copy ctors en size() members e.d.
Het kan dus ook zo:

C++:

class play_lijst{
public:
    play_lijst( vector <int> const& mp3s ) : 
            mp3_index( mp3s )
    {
    }
    void add_song(int i) {
    mp3_index.push_back(i);
    }
    
    void get_songlist(){
        for( int j=0;  j < mp3_index.size(); ++j )
            cout <<  j << ':' << mp3_index[j]<< '\n';
    }
    
private:
    vector <int> mp3_index;
};

Scheelt weer.