2008. jan. 5., szombat
Megjegyzesre erdemes: az iftelenites utani kod az elso (novelos) esetben jelentosen lassabb, mint az ifes, legalabbis egy gyors kis meres utan itt a laptopomon. Gondolom, akkor a csokkentos is.
 
2008. jan. 2., szerda
Nos, draga barataim! Csak felig csinalok segget a szambol... Javitgattam es bovitettem a BigInt osztalyt. Amit most tud:
  • kulonfele konstruktorok
  • abszolut ertek
  • ket BigInt osszehasonlitasa (<, > es ==)
  • ket vagy tobb BigInt osszeadasa
  • ket vagy tobb BigInt kivonasa
  • az elobbi ket muvelet kombinacioi
  • cout
  • mar nem bugzik az osszeadas (hasznald a mostani kodhoz tartozo test.cpp-t az elozo BigInt.cpp-vel, oszt' meglatod, mire is gondolok!)
Amit nem tud es nem is fog tudni egy darabig:
  • szorzas
  • osztas
  • maradekos osztas
  • float-bol BigInt (egeszresz)
  • gyors cout. Ha lefuttatod cout nelkul (test_without_couts.cpp), olyan 40-szeres gyorsulast tapasztalhatsz. Ami nem jo.
Hogy miert nem csinalom meg most? 25-en allamvizsgazok, az mas szkilleket kovetel meg. Addig a BigInt project jegelve, utana befejezem.

Friss verzio itt. Batran lehet minositeni, javito szanadeku kritikakkal elni!
 
2007. dec. 28., péntek
Bemelegitesnek egy kis iftelenites.
Ehelyett:

int i = 0;
while(1)
{
        if(i == 5)
                i = 0;
        std::cout << i << std::endl;
        i++;
}

ezt:

int i = 4;
while(1)
{
        i = (i + 1) % 5;
        std::cout << i << std::endl;
}

A csokkentes meg mondjuk ez:

int i = 4;
while(1)
{
        std::cout << i << std::endl;
        i = (i - 5) % 5 + 4 ;
}

Holnap meg BigInt.cpp kodolas lesz.
 
2007. dec. 24., hétfő
Visszatertem. Napi nyolc ora kodolas utan nincs kedve az embernek meg otthon is ezzel szarozni. Arrol nem is beszelve, hogy egy rendes fejlesztokornyezet utan mennyire kenyelmetlen a vim-gcc paros. De eros leszek. Heti minimum egy post. Ez a cel.
 
2007. júl. 15., vasárnap
"The 'const' system is one of the really messy features of C++."
/.../

A hetvege az eddigi kod javitasaval telik. Az operator+ mostani verzioja ugyanis eleg gyenge. Merhogy az alabbi esetben mukodik:

BigInt bi = 2;
BigInt sum = bi + 3;

A kod mukodik.

Ellenben ha az alabbi kodot probaljuk leeroltetni a fordito torkan...

BigInt bi = 2;
BigInt sum = 3 + bi;

...visszaoklendezi. Miert? A bi + 3 maskeppen is felirhato, csak nem szokas. Igy: bi.operator+(3) A bi-nek van operator+ fuggvenye, ugyan BigInt parametert var, de a 2-esbol lehet BigInt-et varazsolni, szuper. A 3 + bi viszont 3.operator+(bi) alakba irhato at a fenti logika szerint. Ez nem mukodhet.

Megoldas under construction, a const varazsszo lesz a baratunk, eloljaroban. Meg a nemtagfuggvenyek.
 
2007. ápr. 29., vasárnap
Egyszer folytatom am... Csak van mit csinalnom a cegnel is. Meg kurvara nincs kedvem a kivonason agyalni. Nem beszelve a szorzasrol es az osztasrol...
 
2007. márc. 23., péntek
Uj verzio. Kod itt.
 
2007. márc. 14., szerda
Meg destruktor es a valgrind-et se artana rauszitani.
 
2007. márc. 13., kedd
Most nem lesz kod, csak magyarazat.

Az int problemaja a kovetkezo: limitalt a merete. Az esetek nagyreszeben azert eleg, de megse szeretjuk a korlatokat. A megoldas: dinamikusan foglalt memoriaban tarolni a szamot, ha kifogytunk a digitekbol, foglalni meg. Amig van. Igy is vannak korlatok, de azert ez teljesen mas erzes.
Pillanatnyilag van egy konstruktorunk, ami string bemenetre feltolti a string altal reprezentalt szammal a memoriat.
Azonkivul van egy getValue fuggvenyunk, ami megmutatja, mi is van abban a memoriadarabkaban.

Kezdetnek ez vidam, finomitas boven belefer.
A tervezett feature-ok:
  • konstruktorok int-re, char*-ra
  • copy konstruktor, akarmi is legyen az. Kell!
  • << es >> operatorok
  • alapmuveletek operatorai BigInt-re
  • alapmuveletek operatorai int-re
Elso verzio itt.
 
2007. márc. 11., vasárnap
Elkiabalom: a neheze megvan.
 
Régebbiek | Végére »