Programiranje u C++-u - pitanja i odgovori

Znači imaš polje struktura koje ti predstavlja meni. Indeksi u tom polju odgovaraju pojedinim itemima iz menija (recimo plain egg bi imao indeks 0, bacon and egg 1, itd...).

Ispišeš pred korisnika taj meni, nakon čega on u petlji utipkava brojeve onoga što želi naručiti. Postaviš petlju tako da nekakav poseban broj znači kraj upisa (recimo broj 0).

Te brojeve pohranjuješ u nekakvo polje, te kada korisnik napokon izađe iz petlje (odabrao je sve što je htio) ostane ti polje u kojemu se nalazi njegov odabir. Dalje s tim radiš što hoćeš...

 milisekunde mijenjaj u sekunde ili već po potrebi.

iz cijelog koda je jedino bitno da thread možeš štopati u c11 standardu i baratiti njime ili njima kao što koristiš lakoćom

cout<< "hello bug";

/*************************/
/*/  ---CPP11 ISO---    /*/
/*/                     /*/
/*/  dodaj ako ti nije  /*/
/*/  vec defaultno      /*/
/*/  pri kompilaciji    /*/
/*/  -std=c++11         /*/
/*************************/


#include <iostream>
#include <thread>
#include <chrono>
using namespace std;
using namespace std::chrono;
typedef unsigned int uint32;
 
class Timer {
    public:
    void begin();
    void end();
  
    private:
    high_resolution_clock::time_point m_times[2];
  
  
};
void Timer::begin()
{
    m_times[0] = high_resolution_clock::now();
}

void Timer::end()
{
    m_times[1] = high_resolution_clock::now();
    duration<double> time_span = duration_cast<duration<double>>(m_times[1] - m_times[0]);
  
    cout << "pauza je trajala " << time_span.count() << " milisekundi.";
}
 

/* -------------------------------------------------------- */
/**
 * ovo je okosnica a timer je tu samo da vidis
 * vizualno kako imamo sleep od 0.5 sekundi
 **/
inline void sleep__(uint32 ms)
{
    this_thread::sleep_for(std::chrono::milliseconds(ms));
}
/* -------------------------------------------------------- */

int main()
{
   Timer timer;
 
   timer.begin();
 
   sleep__(500);  // pauziramo pola sekunde
 
   timer.end();
 
 
   return 0;
}

Probaj ovako:

https://ideone.com/7p3yRh

/*************************/
/*/  ---CPP11 ISO---    /*/
/*/                     /*/
/*/  dodaj ako ti nije  /*/
/*/  vec defaultno      /*/
/*/  pri kompilaciji    /*/
/*/  -std=c++11         /*/
/*************************/

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
typedef unsigned int uint;

#define NOT_IN_ORDER 0xff  // definiraj ono sto ne pase
                           // vidi nize i bit ce jasnije


// struct Menu nosi osnovne podatke
struct Menu
{
    Menu(string menuItem , float menuPrice);

    string MenuItem;
    float MenuPrice;

};

Menu::Menu(string menuItem , float menuPrice)
    : MenuItem(menuItem) , MenuPrice(menuPrice)
{
}


// u klasi Restaurant rijesavamo cijeli zadatak
class Restaurant
{
public:
    Restaurant();

    // serve i display su dostupni
    // ostalo nema potrebe biti public
    // jer samo Restaurant interno
    // barata onime sto je pod private
    void serve();
    void display();


private:
    vector<Menu> m_menus
    {
        // c++11 dopusta iniciranje u samoj klasi
        // iskoristit cemo to upravo sad
        Menu("Plain_Egg",1.45),
        Menu("Bacon_and_Egg",2.45),
        Menu("Muffin",0.99),
        Menu("French_Toast",1.45),
        Menu("Fruit_Basket",2.49),
        Menu("Cereal",0.69),
        Menu("Coffee",0.50),
        Menu("Tea",0.75)
    };

    // ovime vrsimo provjeru unesenog MenuItem-a
    uint processWhat(string what);

    // u order punimo index odnosno offsete m_menus-a
    // vidi nize da bude jasnije
    vector<uint> order;

};

Restaurant::Restaurant()
{
    cout<< "u ponudi restauranta imamo :\n\n";

    // c++11 auto je dobra stvar koja ubrzava code
    // dakle iskoristimo ga
    for(auto x : m_menus)
        cout<< x.MenuItem << " " << x.MenuPrice << endl;
}


void Restaurant::serve()
{
    cout<< "\nchoose menu\n\n";

    string terminateString = "done";
    string what = "";

    while(what != terminateString)
    {
        cin>> what;

        uint offset = processWhat(what);
        if(offset != NOT_IN_ORDER)
        {
            // ukoliko je narudzba jednaka posojecem menu
            // u order stavljamo offset iz m_menus-a
            // vidi jos nize
            order.push_back(offset);
            cout<< "OK , another one or type done for exit\n";
            }
        else
            cout<< "not in order , try again or type done for exit\n";

    }

    display();
}


uint Restaurant::processWhat(string what)
{
    vector<Menu>::iterator it = find_if(m_menus.begin(),m_menus.end(), [&] (Menu a)
    {   //c++11 lambda
        return (a.MenuItem == what);
    }
                                       );
    // ukoliko menu koji je user upisao postoji
    // njegov offset u m_menus-u dobijes pointer aritmetikom
    // it - m_menus.begin() a ukoliko menu ne postoji vrati define s vrha price
    return (it == m_menus.end() ? NOT_IN_ORDER : (it - m_menus.begin()));
}


void Restaurant::display()
{
    // na kraju ispis svega
    float price = 0;

    cout<< "\nNARUDZBA SADRZI :\n";
    for(auto x : order)
    {
        cout<< m_menus[x].MenuItem << endl;
        price += m_menus[x].MenuPrice;
    }

    cout<< "\n\n\nTOTAL : " << price << "$\nDODJITE NAM OPET\n\n";
}



int main()
{
    Restaurant BUG_RESTAURANT;
    BUG_RESTAURANT.serve();


    // pozdrav i sretno
    return 0;
}

Evo ovako:

-ako ukupna kilaza zavrsava na nesto sto nije 0 ili 5, robu nije moguce isporucit bez otvaranja

-ako je ukupna kilaza manja od 10 robu nije moguce isporuciti

-ako ukupna kilaza zavrsava na 5, tada mozes koristit jednu vricu od 15kg i smanjit preostalu kilazu (vrica od 15 ce bit jedna ili nijedna) - skok na zadnju tocku

-nakon smanjenja kilaze, provjerit jeli preostala kilaza veca ili jednaka 20kg - ako je, povecat broj vrica od 20kg i smanjit preostalu kilazu - skok na zadnju tocku

-nakon smanjenja kilaze, a ukoliko prethodna tocka nije ispunjena, provjerit jeli preostala kilaza veca ili jednaka 10kg - ako je, povecat broj vrica od 10kg i smanjit preostalu kilazu (vrica od 10kg ce bit jedna ili nijedna) - skok na zadnju tocku

-ponavljat dok preostala kilaza ne dodje na 0kg. 

Nisam racuna da se daje gotovi kod, ali kad vec ide, onda i moja varijanta... 

#include <iostream>

using namespace std;

int main()

{

   int ukupno=0,n20=0,n15=0,n10=0;

   cout << "Unesi kg za isporuku:";

   cin >> ukupno;

   int ukupno2=ukupno;

   cout << "Uneseno kg:" <<ukupno<< endl; 

   do

   {

     if((ukupno%10)==5)

     {

       ukupno-=15;

       n15++;

     }

     else if((ukupno-20)>=0)

     {

       ukupno-=20;

       n20++;

     }

     else

     {

       ukupno-=10;

       n10++;

     }

   } while (ukupno!=0);

   cout<<"Za ukupno "<<ukupno2<<"kg koristeno je "<<n20<<" vrica od 20kg, "<<

   n15<<" vrica od 15kg, i "<<n10<<" vrica od 10kg."<<endl;

   return 0;

}

U zadatku pise da se ispisu sve mogucnosti. Tvoja ce varijanta ispisati samo jednu.

#include <fstream>

#include <iostream>

using namespace std;

int main ()

{

   int brClanova = 9;

   int polje[20] = {10,20,30,40,50,60,70,80,90}; //da li su nule pohranjene u ostalim pozicijama u polju, nakon ovih inic. brojeva? ili neki random brojevi?

   int *odrediste = polje + brClanova; //zasto kada bi ispisao vrijednost *odrediste dobivam broj 0? cout << *(odrediste);

   int noviBroj = 15; 

   while (*(--odrediste) > noviBroj)

   {

     if(odrediste < polje)

       break;

     *(odrediste + 1) = *odrediste;

   }

   *(odrediste + 1) = noviBroj;

   brClanova++;

   for (int i = 0; i<brClanova; i++)

     cout << polje[i] << " " ;

}

Ako moze neko objasnit komentare. Hvala.

Inace program umece broj 15 u listu brojeva tako da na kraju i dalje lista bude sortirana.

Ajde, pošto sam imao upit na pp od drugog forumaša za sličnu stvar, da odgovorim i ja (inače pitanja se šalju ovdje, a ne na pp)

int  niz[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

izraz (niz + 9) je aritmetika pokazivača i označava adresu elementa niz[9], a na toj adresi je deseti element niza, pošto je prvi element niza na adresi (niz + 0), odnosno na toj adresi se nalazi element niz[0].

Dakle, izrazima *(niz + 1) i niz[1] ćemo dohvatiti element 2, a izrazima *niz i niz[0] ćemo dohvatiti element 1.

btw. trebao si ispisati taj niz i vidjeti da od desetog do dvadesetog elememta inicijalizira 0.

U stvari, imaš još jedan bolji i brži pristup umjesto da ideš ispisivati niz. Ovi naši moderni IDE-ovi su tu da nam pomognu. pa zašto to ne iskoristiti. Ja mogu govoriti za VS jer njega koristim. Opališ breakpoint sa lijeve strane linije koda za varijablu koju hoćeš ispitati. Nakon toga stisneš F5, tj. u menu Debug - Start Debbuging. Kad se izvođenje programa na liniji gdje je break point zaustavi sa F11 ideš korak po korak tj. liniju po liniju koda i pratiš dva prozora Locals i Call Stack.

U prozoru Locals pratiš lokalne varijable u funkciji u kojoj se nalaziš i tu na tvom primjeru vidiš odmah da je od desetog do dvadesetog elementa za tvoj niz inicijalizacija izvršena sa 0. Prozor Call Stack ti govori o funkcijama koje su pozvane i koje su na stacku, što daje i pregled programa i način je učenja rekurzije uz kombinaciju sa prozorom Locals. Možeš probati npr. na ovoj gore Kapetanovoj rekurziji, koju je on btw. super napravio.

Pozz, radim po tutorijalu game programming u SDL-u na početku sam svega pa me zanima zašto se ne može ovdje koristiti obična main(void) funkcija nego tip funkcije kakav je u kodu s ova dva argumenta?

Zašto se pokazivači inicijaliziraju na nul vrijednost?

int main( int argc, char* args[] )

{ //The images

 SDL_Surface* hello = NULL;

 SDL_Surface* screen = NULL;

Zato što SDL koristi vlastitu main funkciju, a tvoju main funkciju koju ti definiraš u programu preimenuje u SDL_main. Za to već koristi unaprijed definiran prototip, pa pokušaji da definiraš main funkciju bez parametara dovode do greške.

Dio iz sdl.h headera:

#define main    SDL_main

/** The prototype for the application's main() function */
extern C_LINKAGE int SDL_main(int argc, char *argv[]);

Zato što je to dobra praksa. Ako ih slučajno koristiš prije nego što im dodijeliš nekakvu važeću vrijednost, lakše je primijetiti nevažeću vrijednost ako je ona NULL nego ako je nekakav nasumični broj kojeg ne možeš lagano provjeriti je li važeća memorijska adresa ili nekakvo smeće.

U svakom slučaju radit će i bez incijalizacije, ovo ti je samo da lakše uhvatiš greške sa svoje strane.

A i neke funkcije iz biblioteka imaju detekciju NULL pokazivača pa ti fino vrate grešku umjesto da naprasno sruše program pokušavajući čitati/pisati na nevažeću adresu (mišljenja su ovdje podijeljena jer postoje zagovornici ideje da je bolje da se program jednostavno sruši, uz obrazloženje da je tako puno lakše primijetiti grešku, umjesto da program nastavi raditi ali u nekakvom netočnom stanju).

http://en.wikipedia.org/wiki/Linked_list

http://cslibrary.stanford.edu/103/LinkedListBasics.pdf

Čitaj. Ne vidim što se tu ima posebno za objašnjavati nije to nekakav misterij.

Kod jednostrukih lista svaka struktura u sebi sadrži pokazivač na slijedeću strukturu u nizu. A kod dvostruko vezanih lista svaka struktura sadrži pokazivače na prethodnu i na slijedeću strukturu u nizu. Jako jednostavno.

Vrati se sa konkretnim pitanjima, a ne traženjem rješenja cijelog zadatka. Zadatak je teška trivijalnost i sudeći po onome što si do sada rješavao trebao bi ga znati riješiti ko iz topa.

EDIT:

Ako još nisi skužio, za razumjevanje vezanih listi (i ne samo vezanih listi) moraš prvo razumjeti pokazivače. Kako mi je već lagano dosadilo objašnjavati što su to pokazivači, složio sam jednu grafiku koja vizualizira sadržaj jednog dijela radne memorije (u ovom slučaju stacka), za vrijeme izvođenja programa:

int main()
{
    int a = 52;
    int *b = &a;
    char rijec[] = "Text";

    return 0;
}

Slika je preslika stvarnog stanja sa stvarnim adresama (no to se može razlikovati od računala do računala ovisno o kompajleru, procesoru, operacijskom sustavu...), i vizualizira nekoliko bitnih stvari:

1. Razmještaj varijabli u memoriji.
2. Kako je adresa neke varijable uvijek adresa prvog bajta te varijable u memoriji.
3. 32 bitni cijeli broj zauzima 4 bajta u memoriji, jer je 32 / 8 = 4 (svaki bajt ima 8 bita).
4. Što to zapravo znači kada se kaže da je vrijednost pokazivača memorijska adresa nečega u memoriji (u ovom slučaju vrijednost pokazivača 'b' je memorijska adresa varijable 'a').
5. Pokazivač također, kao i svaka druga varijabla u memoriji, ima svoju adresu. Ona je u slučaju pokazivača 'b' : 0x22FF4C
6. Polje 'rijec' je zapravo pokazivac na prvi char (bajt) iz tog polja. Također se vidi i kako su slova zapravo samo hrpa brojeva (ASCII kodovi), kao i null znak koji ima vrijednost 0 i označava kraj stringa.

Memorijske adrese su pisane heksadecimalno kako bi se lakše razlikovale od ostalih vrijednosti (iako je i dalje riječ o običnim cijelim brojevima, samo pisanim na drugačiji način). Također je i inače praksa pisati ih heksadecimalno jer su tako kompaktnije i lakše se čitaju (tracer je to već načeo na prethodnoj stranici).

Iz slike se lijepo vidi zašto je b == 0x22FF48, i zašto je *b == 52. Kada dereferenciramo pokazivač slijedimo tu plavu strelicu.

Eto to ti je brzinski uvod u pokazivače, kako bi lakše mogao probaviti materijale što sam ti nakačio o vezanim listama. Nadam se da će ovo bar malo razbiti nepotrebnu mistiku koja se stvara oko pokazivača.

Drugi link koji ti je rustweaver dao zaista dobro objasnjava i pokazivace i povezane liste, sve s kodom koji je popracen crtezima i lijepo je sve obrazlozeno i napisano preko 26 stranica. Jako dobar link jer sam ga i ja koristio nekad prije za osvjeziti znanje o listama.

Garantirano ces imati sliku o listama - sto i kako - nakon proucavanja tog dokumenta. ;)

...zapravo koristiš ih svakodnevno, da ti malo vizualiziram povezane liste:

otvori file explorer i pogledaj npr disk C: , folderi i fileovi koji su prikazani su jedna lista, kad otvoriš folder prikaže ti drugu listu itd.

Prvo se moraš odlučiti kakvu listu radiš. Da li listu u obliku Stack-a, reda, dvostruko povezanu ili što već.

Pogledaj ovdje primjere:

http://web.math.pmf.unizg.hr/~gmuic/praki/pred9/pred9.html

http://grube.web.srk.fer.hr/marcupic/CTips/Liste.html

Analiziraj ovaj kod. Podatke iz tvoje txt datoteke veže u dvostruku listu i zatim je ispisuje. Pogledaj komentare, ne da mi se pisati objašnjenja nadugo.

#include<iostream>
#include<fstream>
#include<string>
using namespace std;

struct cvor
{
   string pjesma;
   string izvodjac;
   string vrijeme;
   cvor *naprijed;
   cvor *nazad;
}*pocetak = NULL, *trenutni, *pomocni;

void dodaj()
{
   if (pocetak == NULL) // ako na listi nema nijednog cvora
   {
      pocetak = trenutni;
      trenutni->naprijed = NULL;
      trenutni->nazad = NULL;      // ovaj cvor nam je prvi, prednji i zadnji pokazivac su mu null
   }
   else
   {
      pomocni = pocetak;                // uzimamo pomocni cvor i stavljamo ga na pocetak
      while (pomocni->naprijed != NULL)
      {
         pomocni = pomocni->naprijed;   // pomocni cvor seta na kraj liste
      }
      pomocni->naprijed = trenutni;    // onaj na kraju liste prednji veze za nas trenutni kojeg ubacujemo
      trenutni->nazad = pomocni;       // nas trenuni zadnji veze za onog na kraju liste
      trenutni->naprijed = NULL;       // povezali smo trenutni, prednji je null
   }
}


void ispis()
{
   pomocni = pocetak;   // pomocni na pocetak
   while (pomocni->naprijed != NULL)   // pomocni seta do zadnjeg
   {
      cout << pomocni->pjesma << endl << pomocni->izvodjac << endl << pomocni->vrijeme << endl;
      pomocni = pomocni->naprijed;
   }
   cout << pomocni->pjesma << endl << pomocni->izvodjac << endl << pomocni->vrijeme << endl;   // u while je zadnji ostao neispisan
}

int main()
{
   ifstream citaj;
   string linija;
   citaj.open("myPlayList.txt");
   if (citaj.is_open())
   {
      while (!citaj.eof())
      {
         trenutni = new cvor(); // alociramo novi cvor
         getline(citaj, linija);   // kupimo podatke iz datoteke za njega
          trenutni->pjesma = linija;
         getline(citaj, linija);
         trenutni->izvodjac = linija;
         getline(citaj, linija);
          trenutni->vrijeme = linija;
         dodaj();                   // idemo ga dodati na listu
      }
   }
   else
      cout << "greska";
   ispis();   
   return 0;
}