Jedno pocetnicko?

[marko_arsenal]

Kako da iznesem vrednost promenljive iz for petlje, konkretno u metodi ispod mi vraca stalno prazan string, a necu to?

private string filmoviPoZanru(string zanr)
        {
            string str = "";
            for (int i = 0; i < _spisakFilmova.Count; i++)
            {
                if (_spisakFilmova[i].Zanr.DajPodatke() == zanr)
                {
                    str = str + "\n" + nazivFilma(_spisakFilmova[i]);
                }
            }
            return str;
        }

[Sass Drake]

Zbog čega si stavio metudu u private, a ne u public?
Stavi je u public pa vidi onda da li radi, ali sumnjam da je problem ovo

str = str + "\n" + nazivFilma(_spisakFilmova[i]);

jer nisam siguran da je u klasi string preklopljen operator + da radi sa tri promjenljive.
Pokušaj ovako:

if (_spisakFilmova[i].Zanr.DajPodatke() == zanr)
        {
        str += "\n" ;
        str += nazivFilma(_spisakFilmova[i]);
        }

[Todors]

Jel možeš da staviš i ovu metodu nazivFilma(_spisakFilmova[i]), da vidimo šta i ona radi.

[marko_arsenal]

Otkrio sam gresku, ne smem ni da kazem koliko je glupo!
(Lista _spisakFilmova je bila prazna)

[Belphegor]

Bilo mi je dosadno pa sam ti uzeo ideju sebi za vezbu.

Spoiler za KatalogFilmova:

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <iterator>

enum E_ZANR_FILMA
{
    EZF_NEPOZNAT = 0,
    EZF_HORROR,
    EZF_AKCIJA,
    EZF_DRAMA,
    EZF_TRILER,
    EZF_KOMEDIJA
    // ...i ostali
};

std::ostream& operator << (std::ostream& out, E_ZANR_FILMA _zanr)
{
    switch(_zanr)
    {
    case EZF_HORROR:
        {
            out << "HORROR";
        }break;
    case EZF_AKCIJA:
        {
            out << "AKCIJA";
        }break;
    case EZF_DRAMA:
        {
            out << "DRAMA";
        }break;
    case EZF_TRILER:
        {
            out << "TRILER";
        }break;
    case EZF_KOMEDIJA:
        {
            out << "KOMEDIJA";
        }break;
    default:
        {
            out << "NEPOZNAT";
        }break;
    };
    return out;
}

class Film
{
private:

    std::string  ime;
    E_ZANR_FILMA zanr;
    short        godina;

public:

    Film() : ime(), zanr(EZF_NEPOZNAT), godina(0)
    {
    }

    Film(const Film& f) : ime(f.ime), zanr(f.zanr), godina(f.godina)
    {
    }

    Film(Film&& f) : ime(std::move(f.ime)), zanr(f.zanr), godina(f.godina)
    {
    }

    Film& operator = (const Film& f)
    {
        if(this != &f)
        {
            ime    = f.ime;
            zanr   = f.zanr;
            godina = f.godina;
        }
        return *this;
    }

    Film& operator = (Film&& f)
    {
        if(this != &f)
        {
            ime    = std::move(f.ime);
            zanr   = f.zanr;
            godina = f.godina;
        }
        return *this;
    }

    template<typename TIme, typename TZanr, typename TGod>
    Film(TIme&& _ime, TZanr _zanr, TGod _godina) : ime(std::forward<TIme>(_ime)), zanr(_zanr), godina(_godina)
    {
    }

    template<typename TIme>
    void PostaviIme(TIme&& _ime)
    {
        ime = std::forward<TIme>(_ime);
    }

    void PostaviZanr(E_ZANR_FILMA _zanr)
    {
        zanr = _zanr;
    }

    void PostaviGodinu(short _godina)
    {
        godina = _godina;
    }

    const std::string& Ime() const
    {
        return ime;
    }

    E_ZANR_FILMA Zanr() const
    {
        return zanr;
    }

    short Godina() const
    {
        return godina;
    }

    friend class FPoImenu;
    friend class FPoZanru;
    friend class FPoGodini;
    friend class FOdredjenZanr;
};

class FPoImenu
{
public:
    bool operator () (const Film& l, const Film& d) const
    {
        return l.ime < d.ime;
    }
};

class FPoZanru
{
public:
    bool operator () (const Film& l, const Film& d) const
    {
        return l.zanr < d.zanr;
    }
};

class FPoGodini
{
public:
    bool operator () (const Film& l, const Film& d) const
    {
        return l.godina < d.godina;
    }
};

class FOdredjenZanr
{
private:
    E_ZANR_FILMA zanr;
public:
    FOdredjenZanr(E_ZANR_FILMA _zanr) : zanr(_zanr)
    {
    }
    bool operator () (const Film& _film) const
    {
        return zanr == _film.zanr;
    }
};

class KatalogFilmova
{
private:

    std::vector<Film> vfilmovi;

    class IspisiFilmove
    {
    public:
        void operator () (const Film& _film) const
        {
            std::cout << "ime: " << _film.Ime() << ", god.: " << _film.Godina() << ", zanr: " << _film.Zanr() << std::endl;
        }
    };

public:

    KatalogFilmova()
    {
        vfilmovi.reserve(8);

        vfilmovi.push_back(Film("The Last Castle", EZF_AKCIJA, 2004));
        vfilmovi.push_back(Film("Amos And Andrew", EZF_KOMEDIJA, 1995));
        vfilmovi.push_back(Film("The Fourth Protocol", EZF_AKCIJA, 1998));
        vfilmovi.push_back(Film("Borderline", EZF_DRAMA, 2002));
        vfilmovi.push_back(Film("Just Married", EZF_KOMEDIJA, 1986));
        vfilmovi.push_back(Film("15 Minutes", EZF_TRILER, 2000));
        vfilmovi.push_back(Film("Hero", EZF_DRAMA, 1993));
        vfilmovi.push_back(Film("Cube 2", EZF_HORROR, 2009));
    }

    void IspisiListuNesortiranu()
    {
        std::cout << "==================== FILMOVI, NESORTIRANI ====================" << std::endl;
        std::for_each(vfilmovi.begin(), vfilmovi.end(), IspisiFilmove());
    }

    void IspisiListuPoImenu()
    {
        std::cout << "==================== FILMOVI, PO IMENU ====================" << std::endl;
        std::sort(vfilmovi.begin(), vfilmovi.end(), FPoImenu());
        std::for_each(vfilmovi.begin(), vfilmovi.end(), IspisiFilmove());
    }

    void IspisiListuPoZanru()
    {
        std::cout << "==================== FILMOVI, PO ZANRU ====================" << std::endl;
        std::sort(vfilmovi.begin(), vfilmovi.end(), FPoZanru());
        std::for_each(vfilmovi.begin(), vfilmovi.end(), IspisiFilmove());
    }

    void IspisiListuPoGodini()
    {
        std::cout << "==================== FILMOVI, PO GODINI ====================" << std::endl;
        std::sort(vfilmovi.begin(), vfilmovi.end(), FPoGodini());
        std::for_each(vfilmovi.begin(), vfilmovi.end(), IspisiFilmove());
    }

    void IspisiListuOdredjenogZanra(E_ZANR_FILMA _zanr)
    {
        std::cout << "==================== FILMOVI, " << _zanr << " ZANRA ====================" << std::endl;
        std::vector<Film>::iterator vitr = std::partition(vfilmovi.begin(), vfilmovi.end(), FOdredjenZanr(_zanr));
        std::for_each(vfilmovi.begin(), vitr, IspisiFilmove());
    }
};

int main()
{
    {
        KatalogFilmova k;
        k.IspisiListuNesortiranu();
        k.IspisiListuPoImenu();
        k.IspisiListuPoZanru();
        k.IspisiListuPoGodini();
        k.IspisiListuOdredjenogZanra(EZF_AKCIJA);
    }

    std::cout << "Press enter to exit...";
    std::cin.get();
    return 0;
}

ako neko primeti neku gresku ili misli da je moglo drugacije, neka se izjasni.

Edit: Dodato izlistavanje po odredjenom zanru.

[irreal]

Sass Drake kaže:

Zbog čega si stavio metudu u private, a ne u public?
Stavi je u public pa vidi onda da li radi, ali sumnjam da je problem ovo

str = str + "\n" + nazivFilma(_spisakFilmova[i]);

jer nisam siguran da je u klasi string preklopljen operator + da radi sa tri promjenljive.
Pokušaj ovako:

if (_spisakFilmova[i].Zanr.DajPodatke() == zanr)
        {
        str += "\n" ;
        str += nazivFilma(_spisakFilmova[i]);
        }

problem je resen u medjuvremenu (i bilo je jasno da greske kod scope-a varijable nema).

al cisto da znas za ubuduce, da li je funkcija private ili public utice na njenu vidljivost iz ostatka koda i utice na to odakle ce moci da je poziva a odakle ne (dakle, ako je private moze da je poziva samo unutar klase u kojoj se nalazi, ne preko reference ka instanci klase u kojoj se nalazi)

drugo, apsolutno mozes da nizes sa + kolko hoces jer se razresava jedno po jedno, bez potrebe da se nesto posebno "preklapa" + operater

[Sass Drake]

^ Jel meni govoriš ovo za public, protected i private? Ja to već znam, a što se tiče preklapanja operatora +, ako ti se kao rezultat ne vraća objekat iste vrste kao i operandi (npr. vraća long umjesto "NekaKlasa"), ne može se nizati koliko hoćeš, nažalost.

[Todors]

Pa potpuno ti je sve jedno da lićeš koristiti a += b ili a = a + b! Ne razumem zašto bi se ova dva načina razlikovala u bilo kojem slučaju.

[Sass Drake]

^ Nisam mislio na to nego na ovo:

a = Obj1 + Obj2 , gdje je a npr. long, a operator je preklopljen tako da vraća long. U tom slučaju ovo neće da radi: a = Obj1 + Obj2 + Obj3.
irreal, sad opet pročitah kod u prvom postu, moja greška, zaboravio sam da ispravan IDE ne bi dozvolio kompajliranje u slučaju da pokuša da pristupi direktno članu u private. DevCPP tu ne ubrajam.

[Todors]

Da slažem se za objekat, al otkud ti onda to da je metoda nazivFilma objekat?

[Sass Drake]

^ Mislio sam uopšteno, a ne na program o filmovima mada nigdje nisam napisao da je nazivFilma objekat.

[Belphegor]

Todors kaže:

Pa potpuno ti je sve jedno da lićeš koristiti a += b ili a = a + b! Ne razumem zašto bi se ova dva načina razlikovala u bilo kojem slučaju.

Nevezano sa ovim postom ima razlike , kod:

a = a + b;

pravi privremeni objekat od opercije a+b i dodeljuje vrednost u a, a

a += b

apenduje vrednost b u a.
Obicno kad se overloaduje operator + on vraca privremen objekat:

Foo operator + (const Foo& o)

a operator += vraca referencu:

Foo& operator += (const Foo& o)

Mada je svejedno ako brzina nije bitna.

[irreal]

Sass Drake kaže:

irreal, sad opet pročitah kod u prvom postu, moja greška, zaboravio sam da ispravan IDE ne bi dozvolio kompajliranje u slučaju da pokuša da pristupi direktno članu u private. DevCPP tu ne ubrajam.

em to, em kako god taj kod bio pozvan, on je rekao da dobija rezultat ali prazan, a ne da ne dobija nikakav rezultat, tako da je podatak o tome da li je funkcija private, public ili protected totalno ne bitan jer on taj kod nekako poziva, samo nije radio kako treba.

a sto se tice nizanja, jedna je stvar da li "radi" vezivanje 3 za redom a druga da li si ti kriv sto pokusavas da nizes nesto sto vraca drugi tip varijable.

dakle, nizanje vise za redom svakako radi, ali ako se zadese razliciti tipovi koji ne mogu da se vezu naravno da ce izbaciti gresku i da nece magicno proraditi

u svkaom slucaju, mislim da smo apsolvirali temu.

[Todors]

Belphegor kaže:

Nevezano sa ovim postom ima razlike , kod:

a = a + b;

pravi privremeni objekat od opercije a+b i dodeljuje vrednost u a, a

a += b

apenduje vrednost b u a.
Obicno kad se overloaduje operator + on vraca privremen objekat:

Foo operator + (const Foo& o)

a operator += vraca referencu:

Foo& operator += (const Foo& o)

Mada je svejedno ako brzina nije bitna.

Nije šija nego vrat. Al dobro, bolja je praksa da se koristi složeni operator dodele od jednostavnog, ali ni jedno ni drugo nije pogrešno.