Programiranje u C++-u - pitanja i odgovori

Hvala ti puno, sve sam shvatio ! Tek sad vidim koje sam gluposti pitao 

Onaj tko je napisao ovaj snippet , stavio je definiciju N-a bez posebnog valjanog razloga.

Drugim riječima , moglo je biti :

unsigned int N = 20; 

const unsigned int N = 20;

...

...

...

Dakle , proizvoljno je odobrano definirati N kroz  #define N 20

P.S (ovako napisan kod je C-like tako da eventualno bi odgovor mogao biti  -- iz navike -- (više je ovaj način C-ovski) no kako je pitano u sekciji C++ pitanja , i dalje je krajnji odgovor - proizvoljno)

Ovaj se zadatak može riješiti na bezbroj načina.

Ti si nešto počeo u C stilu no probaj se prebaciti mentalno na C++ što bi značilo za početak-> forsiraj klase gdje god stigneš.

Naravno da je C odličan jezik i nije bez vraga i dan danas na TIOBE ljestvici čini mi se prvi no C++ je kralj jer u njemu možeš pisati ovako kako si počeo i na sasvim drugi (lakši , razumljiviji i brži način).

Pošto je ovo sekcija C++ pitanja , napravio sam ti shodno tome 95% riješenja bar da se dodirnu klase (onih 5% fali da program odradi i za velika slova a to zamoljavam tebe da dodaš).

Malo prouči kod , ako što nije jasno a pretpostavljam da neće biti  pitaj pa se nadam ako  neću biti online da ćeveć netko odgovoriti traženo.

U kratko :

koristimo dvije klase kako bi si olakšali život i manipulaciju podacima

forsiramo C++11 style iako je već pomalo blesavo to naglašavati pošto nam je pred vratima novi standard C++14 (male izmjene no računa se kako novi)

upotreba std::algorithm i std::vector ponovo kako bi si olakšali život.

Ugodno kodiranje želim dalje !

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

//==========================//
bool program_finish {false};
//==========================//

class Samoglasnik
{
public:
    Samoglasnik(char c) : m_c(c) {}
    void raise();
    char sign();
    unsigned amount();

private:
    char m_c;
    unsigned m_n {0};
};

void Samoglasnik::
raise()
{
    ++m_n;
}

char Samoglasnik::
sign()
{
    return m_c;
}

unsigned Samoglasnik::
amount()
{
    return m_n;
}



class Samoglasnici
{
public:

    bool process(char c);
    void log();

private:
    bool isOver();

    vector<Samoglasnik> m_d
    {
        Samoglasnik('a'),
        Samoglasnik('e'),
        Samoglasnik('i'),
        Samoglasnik('o'),
        Samoglasnik('u')
    };

};

bool Samoglasnici::
isOver()
{
    for(auto x : m_d)
    {
        if(x.amount() == 0)
            return false;
    }

    return true;
}

bool Samoglasnici::
process(char c)
{
    auto ret = find_if(m_d.begin(),m_d.end(), [&,c](Samoglasnik s)
    {
        return (s.sign() == c);
    });

    ptrdiff_t ptrdiff = ret - m_d.end();
    if(ptrdiff != 0)
    {
        ret->raise();
    }

    return isOver();
}


void Samoglasnici::
log()
{
    for(auto x : m_d)
        cout<< "\nsamoglasnik " << x.sign() << " se pojavljuje " << x.amount() << " puta";

}


void
mainLoop(Samoglasnici& data)
{
    while ( ! program_finish)
    {
        cout<< "unesi jedan znak : ";
        char c;
        cin>> c;
        program_finish = data.process(c);
    }
}


int main()
{
    Samoglasnici data;
    mainLoop(data);

    data.log();



    cout << "\n\nexiting..." << endl;
    return 0;
}

kasno palim ali ako nekom treba kod:

http://ideone.com/kUT4oD

nije mi se dalo zafrkavati sa lowercajsanjem...

Prije svega, dijeljenje bi/10 je cjelobrojno dijeljnje sto znaci da tim dijeljnjem neces nikada dobiti 0.1 tj. 1/10 nije jednako 0.1 vec 0. Da bi to popravio stavi 10.0 umjesto 10. Kad napises 10.0 onda je to tipa double (ili float, nisam potpuno siguran) pa ce i dijeljenje rezultirati double tipom. (1/10.0 = 0.1).

Ovo: for(int i=1;i<=b;i++){ c=c*i;} ti nema smisla jer ti for petlja tu pratkicki neradi nista. U svakoj iteraciji ti vrijednost od c prebrises novom vrijednosti i na kraju ce c biti jednako c = b*c. To si mogao odmah napisati. No to opet nema smisla, pa taj dio mozemo izbrisati. Zatim umjesto c= 0 trebamo napisati c = c*2 i kod ce ti normalno raditi:

#include <iostream>
#include <cstdlib>

using namespace std;

int main()
{
    int bi;
    int a=0,b=1,c=1;
    cin >> bi;

    while (bi / 10.>=0.1)
    {
        if (bi%10==1 || bi/10==0.1)
        {
            a=a+c;
            bi=bi-1;
            bi=bi/10;
        }
        else
        {
            bi=bi/10.;
        }
        b++;
        c= c*2;
        cout << bi<<endl; /* ovo sam pisao da vidim dal mi uopce pokrati zadnju znamenku*/
    }
    cout << endl <<"rez: "<< a;
    return 0;

}

Evo ti malo jednostavniji nacin:

#include <iostream>

using namespace std;

int main()
{
    int bi;
    cin >> bi;

    int rez = 0;
    while(bi > 0){
        rez = 2*rez + bi%2;
        bi /= 10;
    }
    cout << rez << endl;
}

Ovdje ti je greška, za zadnju znamenku moraš tražiti ostatak dijeljenja s 10, a ne s 2. 

EDIT: Vidim da i ne radi ovako u svim slučajevima. Ovako bi trebalo izgledati točno rješenje koristeći istu logiku:

#include <iostream>

using namespace std;

int main(void)

{

   int bin,potencija=1,dec=0,znamenka;

   cin>>bin;

   while(bin>0) {

       znamenka=bin%10;

       dec+=potencija*znamenka;

       potencija=potencija*2;

       bin=bin/10;}

cout<<dec;

}

Hvala na brzim odgovorima! To što nije efikasno sad uopće nije bitno:D

Ma nisi toliko ni fulao, šteka jedino sa nulama, koncept je ok, onda samo prepraviti na mastematičku formulu, ali metoda izlučivanja znamenki je dobar koncept. I modulo 2 si ispravno upotrijebio, ne stoje kritike.

#include <iostream>

using namespace std;

int main()
{
    int bi;
    cin >> bi;

    int rez = 0, brojac = -1;
    while (bi > 0){
       rez += (bi % 2) * pow(2, ++brojac);
       bi /= 10;
    }
    cout << rez << endl;
}

Ili bez pow

#include <iostream>

using namespace std;

int main()
{
    int bi;
    cin >> bi;

    int rez = 0, brojac = 1;
    while (bi > 0){
       rez += (bi % 2) * brojac;
       brojac *= 2;
       bi /= 10;
    }
    cout << rez << endl;
}

Nisam to prije vidio, baš zgodno, u jednoj liniji koda. Inače ja bi to osobno riješio tako da bi potencirao preko bitovnog operatora pomaka i postupak sveo na izlučivanje znamenki, ali, sumnjam da to rade u školi, pa nisam htio. Pow bih izbjegao, bitovni operatotri su brži, a u stvari, osim izlučivanja znamenki bila bi samo jedna linja koda.

Zašto uopće izlučivati znamenke? Odnosno, zašto početnu vrijednost unositi kao integer? Zar ne bi bilo pametnije binarni broj tretirati kao string? Manje je nakaradno i može se zapravo i unijeti proizvoljno velik broj. 2⁶⁴ je 18446744073709551616 što znači da čak i u 64 bitni integer možemo nagurati samo 20 znamenki. A to nam daje kapacitet samo za binarno upisane brojeve do 2²⁰-1, odnosno do 1048575₁₀ jer je to 11111111111111111111₂. Malo filozofiram jer vjerojatno nitko neće tako duge kifle od brojeva unositi u zadatku, ali zašto odmah ne učiti učenike da razmišljaju o tim stvarima unaprijed?

#include <stdio.h>

int main()
{
    char binarniBroj[] = "00000000000000000000010001001011"; //1099 decimalno
    unsigned int decimalniBroj = 0;

    for (int n = 31; n >= 0; n--)
    {
        if (binarniBroj[n] == '1')
            decimalniBroj += 1ul << (31 - n);
    }

    printf("%d\n", decimalniBroj);

    return 0;
}

Eto. Ne'š ti posla... uz par preinaka moguće učiniti kôd puno generalnijim.

EDIT:

kao posebna perverzija eto i alternativan pristup

for (int n = 31; n >= 0; n--)
    decimalniBroj += (binarniBroj[n] & 0x1) << (31 - n);

Pa kad mi je pola toga hardkodirano... da nisam toliko lijen bio bih pametniji :D

GCC na x86, očekivano za to iskoristi SAL, ali ispljune i upozorenje: "warning: left shift count >= width of type [enabled by default]"

#include <stdio.h>

int main()
{
    int n;
    scanf("%d", &n);
    return (n << 32);   
}

_main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $32, %esp
    call    ___main
    leal    28(%esp), %eax
    movl    %eax, 4(%esp)
    movl    $LC0, (%esp)
    call    _scanf
    movl    28(%esp), %eax
    movb    $32, %cl
    sall    %cl, %eax
    leave
    ret

Ukratko što se dogodi jest kada shiftaš vrijednost za više mjesta nego što je registar širok, dogodi se jedno veliko ništa. Što je, bar s moje strane, očekivan rezultat na x86 iako C standard tu ne definira što se točno treba dogoditi. MSVC vjerojatno radi istu stvar...

Mislim da su takve provjere kontraproduktivne u ovom slučaju. Cilj je prenijeti originalnu misao kako bi se shvatio princip algoritma, a ne ju zakomplicirati kojekakvim provjerama koje pokrivaju neuobičajene slučajeve. Ima tu još mogućih neobičnih stanja koja dovode do netočnih rezultata, recimo što se dogodi kad se u stringu nalaze znakovi koji nisu '0' i '1'? Možeš reći ali on je upisao samo 0 i 1, ali isto tako možeš onda reći i da je upisao string od samo tri znaka, pa neće sigurno koristiti shift za više od 31 mjesta.

Ako profesor baš inzistira na točnosti sa svakakvim inputom, onda neka si sve te ekstra provjere učenici sami implementiraju, pa ne može se baš sve za njih napraviti a oni samo da sjede na rukama. :P

Iskreno, nisam se toga ni sjetio, mada kod takvog tipa školskih zadataka obično stoji nekakav uvjet tipa 1<=n<=31, pa je zbilja rijetko vidjeti da se pišu iznimke, assertovi, čak i if uvjeti. Ali, u pravu si, kod produkcijskog koda treba sve mogućnosti uzeti u obzir i tu sam dosta pažljiviji, ovdje bi stavio samo if i ušao u petlju ili poslao obavijest da binarni broj ima više od 32 znamenke.

Da stvar bude još bolja, VS mi za ovaj kod kad prijeđem 31 pomak ne daje upozorenje, a za pomak kakav si ti napisao dobijem upozorenje.

Inače kod mene radi _int64, kako je Tracer stavio, ne trebam pisati long long, sizeof operator mi daje 8 bajtova, što će reći 64 mjesta.

Bok! Imam jedno pitanje za vas. Može li se pisati C++ program u Notepad? Molim odgovor!!

Da se nadovežem na domagoja. Programski kod je običan tekst. IDE-i samo bojaju sintaksu kako bi ti taj tekst bio pregledniji. U konačnici kad se .cpp datoteka spremi nema nikakve razlike između npr. notepada i Visual Studia (u to se možeš i sam uvjeriti, otvori u notepadu .cpp datoteke spremljene u Visual Studiu i vidi ima li nešto posebno vezano uz njih).

No zato ne možeš pisati C++ programe u Wordu, jer .doc, .docx, i .rtf datoteke nisu čisti tekst, nego sadrže kontrolne kodove i/ili dodatne tagove za atribute teksta. Odnosno, da budem precizniji, ti možeš nakucati programski kod bez problema u wordu, ali kompajler neće razumjeti datoteku koju je word proizveo, kompajler razumije samo čisti tekst, bez kodova za formatiranje teksta.