[C++] bestanden in een path zoeken.

[Verwijderd]

Ik ben bezig om een programma te maken wat hopelijk ooit eindigd als een interface voor een standalone mp3 speler.

1 van de belangrijkste objecten is uiteraard de lijst met nummers.
dit word in mijn opzet een array of string met alle gegevens.

nou ben ik bezig met de mp3 inless functie die de opgegven directory scant voor mp3 bestanden en deze in de array zet. (en later hopelijk met id3lib verder vult met verdere gegevens)

nou ben ik alleen een beginned C++ programmeur, (voor de rest kan ik wel programmeren hoor dus tis in princiepe alleen de nieuwe syntax en manier van doen die ik moet leren)
en na wat zoeken ben ik erachter gekomen dat je met _findnext en _findfirst zou kunnen met zo i zo wat code die ook in dat topic stond (dit topic)
ook stond er in dat topic dat je met behulp van system( blaat ); ook gewoon kan die informatie kan vinden.

nou is mijn vraag is dat programmeer technies wel slim om dat via system te doen?
het zou voor mij makkelijker zijn, maar stuit ik dan niet op problemen en of meschien snelheids overweging?
(er zullen zeker zo'n ~500 ~1000 mp3'tjes gevonden moeten worden in een recursieve bestands indeling.
(/muziek/CD-naam/mp3-bestand)

(het systeem waar het op gaat werken is overgens linux)

[Verwijderd]

Ok ik heb nu ondekt dat nog _findfirst & _findnext me gaan helpen en dat ook system enkel een bool waarde terug geeft.
ook heb ik ondekt dat ik beter readdir kan gebruiken en wel in de volgende manier..

C:

    bool zoek_mp3()const{
                char track[99];
        int i=0;
        char *blaat;
        blaat = new char;

        DIR * dir = opendir("/muziek");
        struct dirent * de;

        while ((de = readdir(dir)) != 0) {
            blaat  = de->d_name;
            cout<< blaat << '\n';
                       
            i++;
        }
        closedir(dir);
        i=0;

enkel als ik iets in de trent van

track = de->d_naam;
of
track = blaat;
of
&track = blaat;
(met pointers werken is redelijk nieuw voor mij, om de een of andere reden heb ik dat nooit gehad op school. (en heb toch wel al Java en delphi gehad. ))

kan iemand meschien kort uitleggen waarom dat niet werkt en of hoe dan wel?

[Verwijderd]

1.

code:

char* blaat; blaat = new char;

hier maak je een array van 1 karakter.

2.

code:

blaat = de->d_naam;

hier kopieer je de pointer, i.p.v. de inhoud.

mogelijke oplossing:
1.

code:

char* blaat = new char[256];

dit maakt een array van 256 karakters, meestal wel genoeg voor een path name.

2.

code:

strcpy(blaat, de->d_name);

kopieer de inhoud van de->d_name naar blaat;
of als je het iets veiliger wil doen:

code:

strncpy(blaat, de->d_name, 256);

dit kopieerd maximaal 256 karakters, mocht de->d_name langer zijn.

[curry684]

Ik weet niet op welk platform je werkt maar functienamen met leading underscores zijn niet portable. Tis maar dat je het weet Onder Win32 heb je gewoon FindFirst en FindNext in de API zitten.

[Verwijderd]

Verwijderd schreef op 21 June 2003 @ 08:33:
Ok ik heb nu ondekt dat nog _findfirst & _findnext me gaan helpen en dat ook system enkel een bool waarde terug geeft.
ook heb ik ondekt dat ik beter readdir kan gebruiken en wel in de volgende manier..

C:

    bool zoek_mp3()const{
                char track[99];
        int i=0;
        char *blaat;
        blaat = new char;

        DIR * dir = opendir("/muziek");
        struct dirent * de;

        while ((de = readdir(dir)) != 0) {
            blaat  = de->d_name;
            cout<< blaat << '\n';
                       
            i++;
        }
        closedir(dir);
        i=0;

enkel als ik iets in de trent van

track = de->d_naam;
of
track = blaat;
of
&track = blaat;
(met pointers werken is redelijk nieuw voor mij, om de een of andere reden heb ik dat nooit gehad op school. (en heb toch wel al Java en delphi gehad. ))

kan iemand meschien kort uitleggen waarom dat niet werkt en of hoe dan wel?

Zoals gezegd kan er in je blaat char maar 1 teken. Ook moet je het geheugen wat je dynamisch alloceerd (new) weer deleten.
Ik heb nog nooit readdir oid gebruikt dus heb geen idee hoe dat zou werken, maar moetje zelf niet de dir verhogen na het lezen van een element?
Wat is het nut van die i?

Dit is meer C dan C++ code, maar dat terzijde.

--
Ik heb je code geprobeerd en het werkt gewoon. Alleen zit het niet echt netjes in elkaar.

C:

bool zoek_mp3(char *dirname) {
    DIR *dir;
    struct dirent *ent;

    if((dir = opendir(dirname)) == NULL) {
        cout << "Unable to open directory" << endl;
        return false;
    }

    while((ent = readdir(dir)) != NULL) {
        cout << ent->d_name << endl;
    }

    if(closedir(dir) != 0) {
        cout << "Unable to close directory" << endl;
        return false;
    }

    return true;
}

[ Voor 23% gewijzigd door Verwijderd op 21-06-2003 14:02 ]

[Verwijderd]

Het recursive doorscannen van een directory is vrij duur (vooral als je info zoals title,artiest uit de files wil plukken). Momenteel heb ik zoiets met Ogg gedaan. Duurt iets korter dan een minuut of mijn hele home directory te scannen. Tis dan ook handig om die lijst daarna ergens te saven....

[Verwijderd]

Ja was ik al vanplan.
dit is enkel een functie die optimaal gezien maar 1 keer gedraait word.
daarna word gewoon een comma seporated lijst oid. uitgepoept die hij daarna aan het begin van elke sessie inleest en dan enkel kijkt of de bestanden er nog staan.

het is voor mij ook even wennen enzo. na 3 jaar enkel drag&drop type programmeren gedaan te hebben. en in mijn vrije tijd perl is dit toch even heel wat anders.

dit lijkt overgenst meschien C omdat dit een functie is binnen een object.
de complete code ziet er op dit moment) zo uit.
het zal vast allemaal erg fout aan doen en niet netjes zijn maar op het moment werkt het, en elke keer leer ik weer een stukje meer.

C:

/* Created by Anjuta version 1.1.1 */
/*  This file will not be overwritten */

#include <iostream>
#include <string>
#include <list.h>
#include <sys/types.h>
#include <dirent.h>

class track{
    public:
        track(){
        }
        //setters voor de interne variablen
        void set_path(char new_path[256]){ strcpy(path,new_path); }
        void set_num(int new_num){ nummer = new_num; }
        //getters voor de interne variablen
        char* get_path(){ return path; }
        int get_num(){ return nummer; }
        
    private:
    int nummer;
    char path[256];
};


class lijst {
public:
    lijst(){
    }   
    //functie om de track objecten te vullen met de mp3 gegevens.
    //leest directory uit die bij DIR word gedeclareert
    //ToDo:
    //-recursief, onderscheid maken tussen bestand/dir, bestanden enkel pakken mits eindigd op MP3/mp3
    //-ID3 tag uitlezen (via ID3lib (denk ik))
    //-DIR uitlezen uit configuratie bestand
    bool zoek_mp3(){
        //hulp variablen
        int i=0;
        char tmp[256];

        //open de directory die gedefineerd word hier.
        DIR * dir = opendir("/home/warez/muziek");
        struct dirent * de;
    
        //zolang er bestanden in de directory zitten, lees uit.
        while ((de = readdir(dir)) != 0) {
            //copieer de string uit d_name naar tmp (max 256 tekens)
            strncpy(tmp, de->d_name, 256);
            //vul path in de objecten mp3 respectievelijk met de inhoud van tmp
            mp3[i].set_path(tmp);
            i++;
            num_mp3=i-1;
        }
        //sluit de directory weer.
        closedir(dir);
        
        i=0;
        while (i < num_mp3) {
            //sizeof(mp3[i].get_path())-3;
            i++;
            cout << mp3[i].get_path() << '\n';
        }
        
        return true;
    }
private:
    //maak 256 instansies van track aan. (zullen er later meer moeten worden)
    track mp3[256];
    int num_mp3;    //het aantal mp3's
};



int main()
{
    lijst a;
    a.zoek_mp3();
    
    return (0);
}