C++, Delphi, JAVA és egyéb programnyelvek

Started by ignus, 2007-06-05, 15:03:45

Previous topic - Next topic

Próféta

Quote from: chilip on 2008-01-02, 15:31:05
ehhez kéne egy lgraph.h-t írni, ti hogy csinálnátok?  :D és minnél hamarabb kéne, ha lehetséges ;)
Ha segítséget vársz el, talán áruld el azt is, hogy mit kéne tudnia ennek az LGraph osztálynak, meg a yourmark glob értéknek?
Vagy mindegy, csak leforduljon?

chilip

#61
jah :D

ed.: sorry, picit belejavítottam, uccsó sor hibás volt :P most már jó sztem a kód, a lényeg hogy leforduljon, sztem most a feladat eggyelőre hogy le tudja tárolni az adatokat a class...

ed.2.:

volt itt egy előző feladat ami hasonló volt (most is valami ilyesmi a feladat)
ez egy korábbi ZH példa alapján készült :D

itt a korábbi
<< aaaa >>
<< aaaa >>

Próféta

Quote from: chilip on 2008-01-02, 15:41:51
ed.: sorry, picit belejavítottam, uccsó sor hibás volt :P most már jó sztem a kód, a lényeg hogy leforduljon
Az előbb belinkelt Graph.h-ból kiindulhatsz?
Mert ha igen, akkor hol a probléma?  :3x3:
Simán felokosítod, hogy címkézett élei legyenek. Ennek megfelelően az adjacenciamátrixban a belső set-et map-re cseréled, és az azt bántó/olvasó metódusokat is megfelelően módosítod. Template nincs, és kidobod ami nem kell (dir, mindenféle metódusok), összvissz ugye default konstruktor, copy konstruktor, és a két add() overload maradjon.

Quote from: chilip on 2008-01-02, 15:31:05és minnél hamarabb kéne, ha lehetséges ;)
Hmmm, vizsga? :D

chilip

most lehet nagyon utálni fogsz, de beraknád ide ami marad? :P

Próféta

Quote from: chilip on 2008-01-02, 16:18:00
most lehet nagyon utálni fogsz, de beraknád ide ami marad? :P
Nem foglak nagyon utálni, de nem.
Ha innen nem megy, és nem tudod konkrétabban jelezni, hogy min akadtál el, akkor megérdemled.

chilip

#65
nos, elkezdtem módosítani, de rengeteg hiba van benne még és a felét nem értem miért...  :3x3:

repost.: prob az hogy mikor megláttam előző ZH példát, megörültem hogy csak ezzel kell mahinálni és elkezdtem analízist tanulni (azt most nagyon kell) és uccsó pár napra hagytam ezt, csak mivel most fél év kimaradt mindenféle C++ nélkül és elötte is csak alapszinten oktatták a nagyon n00b dolgokat (EAF 1) ... beadandóját ennek megírtam, de az teljesen más típusú volt mint a ZH (grep unix parancs implementálása - nagyon kis segítséggel meglett 4es) , és most ezt nem akarom még1x lenyomni  :_piszka: érdekel a C++ , és gyakorolnám is csak most van 2 tárgyam amit harmadszorra vettem fel...

meg amit bevágtam az csak egy 2es, tehát nem vagyok telhetetlen :D

Próféta

Quote from: chilip on 2008-01-02, 16:31:08nos, elkezdtem módosítani, de rengeteg hiba van benne még és a felét nem értem miért...  :3x3:
A C/C++ fordítók egész értelmes hibaüzeneteket tudnak (általában) adni, ha meghiúsul a fordítás. Ha nem érted, mit ír, akkor kérdezd meg tőlünk, esetleg kódmintával együtt. De ne várd, hogy helyetted megírjuk.

Amúgy meg gondolom az, hogy törlöd a template<> szöveget, és helyette mondjuk "typedef int T;" definíciót írsz, meg törlöd a fölösleges metódusokat és az operátort  overloadot, az megy egyedül is. Ezen kívül a set<> cserélendő map<>-re g_t-ben, hogy ne simán csúcshalmazzal legyen összekötve a csúcs, hanem mindegyik összekötéshez egy string címke rendelődjön. Ehhez az új struktúrához hozzáigazítod az add-okat (pl. 2 helyett 3 paraméter).
A sima konstruktor mellé kellene copy konstruktor a mező áthozására, de helyette inkább próbáld meg, hogy a sima konstruktort is eltünteted, mert úgy egyáltalán nem lesz deklarált konstruktorod, és ilyenkor sacc/kb  sekély másolást csináló copy konstruktor generálódik.

chilip

#67
nos nem sikerült, de annyi baj legyen :D progkör 4es lett  :whoah: ez már megcsinálta a napom :D Próféta, köszi a segítséget, a kódot meg lecenzúrázom :D (ne legyen belőle probléma) majd legközelebb jobban iparkodom. ;)

kikuchiyo

Különböző programnyelvek összehasonlítása példaprogramok segítségével:
The Computer Language Benchmarks Game

Engem meglepett, hogy a Java ennyire jól teljesít. Eszembe nem jutott volna pl. n-test-szimulációt írni benne, mégis, a teszt szerint majdnem olyan gyors, mint a C++ (és nem csak annál az egynél).
Failure is the default option

Próféta

#69
Quote from: kikuchiyo on 2008-01-08, 18:43:52
Különböző programnyelvek összehasonlítása példaprogramok segítségével:
The Computer Language Benchmarks Game

Engem meglepett, hogy a Java ennyire jól teljesít. Eszembe nem jutott volna pl. n-test-szimulációt írni benne, mégis, a teszt szerint majdnem olyan gyors, mint a C++ (és nem csak annál az egynél).
Az egyik trükk, hogy server VM-et használnak.

A másik, hogy most 2008 van, nem 1998 :) A Java már nem interpretált nyelv, hanem rendes-tisztességes compileren megy át. Ez a compiler JIT, tehát amikor futni akar egy kód, akkor kerül gyorsan lefordításra natív kóddá (mindjárt figyelembe véve a processzor, cache, stb. sajátságokat, amit precompiler esetén nem lehet). Sőt, a JIT révén még vannak elborult trükkök, hogy pl. runtime újrafordítja-átoptimalizálja az elágazást, ha a használat rácáfol a branch predictionre.

A harmadik, hogy szemétgyűjtéses (GC) memóriakezelést használ, amit szoktak szidni a lassúsága miatt, de amíg a program memóriája nem fogy el, csak foglal és kilépéskor felszabadít, addig a GC sem lassabb, sőt, az új objektum foglalása meg kimondottan gyorsabb (1 db. heap pointert kell megtolni). Már tervezik, hogy C++-ba is bekerül :)

Itt írnak még csomó ilyet: http://www.idiom.com/~zilla/Computer/javaCbenchmark.html
(mondjuk itt direkt sokkolni akarnak olyan példákkal, hogy a java a gyorsabb, ami simán előfordulhat, de azért nem jellemző)

Amúgy az MSIL (also known as .NET) is hasonló.

kikuchiyo

Tegyük fel, hogy egy bizonyos 32 bites architektúrán nincs natív lebegőpontos támogatás. Ezért fixpontos reprezentációt használnék, azaz megszorzom a számokat 2N-nel (ahol N mondjuk 28), és (int)-té alakítom őket.
Az ilyen módon reprezentált számok összeadása triviális, a szorzásuk nem annyira: a naiv eljárás az, hogy az egyiket 64 bites egésszé konvertálom, beszorzom a másikkal, az eredményt right shiftelem N-nel, és visszaalakítom 32 bites egésszé. Ebben az a fájdalmas, hogy a regiszterek 32 bitesek, így a típuskonverzióhoz ki kell nyúlni a memóriába, maszatolni az ottani értékekkel, majd visszaolvasni a memóriából.

Jó lenne, ha az egész műveletet le lehetne rendezni csak a regiszterek használatával. Mondjuk így:
#define FixptMultiply(x, y) ((x>>14)*(y>>14) + (((x>>14)*(y&0x7FFF))>>14) + (((y>>14)*(x&0x7FFF))>>14))

Ennek a módszernek az előnye, hogy nem kell típuskonverziót végezni, minden művelet belefér a 32 bites regiszterekbe (elvileg), ráadásul a shiftelések gyorsak.
QuoteAnother unique feature of the instruction set is the ability to fold shifts and rotates into the "data processing" (arithmetic, logical, and register-register move) instructions, so that, for example, the C statement

    a += (j << 2);

could be rendered as a single word, single cycle instruction on the ***.

    ADD Ra, Ra, Rj, LSL #2

Hátránya, hogy egyelőre nem látom, hogy előjeles egészekre is működne, és három szorzást (meg két összeadást és két maszkolást) kell végrehajtani.
Továbbá az eldobott ((x&0x7FFF)*(y&0x7FFF))>>28 tag miatt veszthetünk a pontosságból.

Van erre valami általam nem ismert, intelligensebb, fájdalommentesebb megoldás?
Failure is the default option

Próféta

Quote from: kikuchiyo on 2008-01-17, 01:23:00Hátránya, hogy egyelőre nem látom, hogy előjeles egészekre is működne, és három szorzást (meg két összeadást és két maszkolást) kell végrehajtani. Továbbá az eldobott ((x&0x7FFF)*(y&0x7FFF))>>28 tag miatt veszthetünk a pontosságból.
Anélkül is vesztesz a pontosságból, pusztán azzal, hogy feldaraboltad és külön kerekítetted. Amúgy most fáradt vagyok, de a 0x7FFF nem túl sok bit? Ha meg nem túl sok, akkor ennek az utsó tagnak még a korai kerekítés miatt 0-vá kell válnia.
Előjeles: TFH 2-es komplemens ábrázolás, mert van még ugye többféle is.
+0.1=0.8000000; -0.1 = F.8000000. Ezek >>14 csonkolása 2000 és 3E000, szorzatuk 7.C000000, nem pedig F.4000000 :( Remélem elszámoltam.
Az overflow is nagy szopás lehet.

EDIT: ja most jut eszembe, az előjeleken segíthet, ha megválasztod, a shift milyen biteken hozzon be balról. Negatívnál hozz be 1-est!

Quote from: kikuchiyo on 2008-01-17, 01:23:00
Van erre valami általam nem ismert, intelligensebb, fájdalommentesebb megoldás?
Ha van, én sem ismerem. http://prog.hu tudástár, perchance?

Nagyon nagy hajtás lehet ám, ha itt a shift-ek számával akarsz spórolni :)

kikuchiyo

Azt közben beláttam, hogy az arithmetic shift (ami a legfelső bitet tologatja be nulla helyett, kettes komplemenses ábrázolásnál 1-et) elvileg jó negatív számokra is.

Azt viszont nem értem, hogy miért veszítenék a pontosságból pusztán a szétdarabolással.
Végül is csak annyit csinálok, hogy ha x és y a két összeszorzandó szám, akkor úgy írom fel őket, hogy x0+x1ε és y0+y1ε. A szorzatuk:
x0y0+(x0y1+x1y0)ε+x1y1ε2.

Megfelelő ε választásával (vagyis a megfelelő shift-faktorral és bitmaszkkal) az első tag a szorzatban pont kitölti a 32 bitet, a második tagból a leshiftelés azt dobja el, ami amúgy sem férne bele a 32 bites pontosságba, a harmadik tag pedig elfelejthető (illetve ott a kerekítés miatt veszíthetünk némi pontosságot.) Az persze valószínű, hogy a >>14 és a 0x7FFF nem megfelelő.

BTW ne aggódj, nem éles projekt :)
Failure is the default option

Próféta

Quote from: kikuchiyo on 2008-01-17, 12:24:00
Azt viszont nem értem, hogy miért veszítenék a pontosságból pusztán a szétdarabolással.
Végül is csak annyit csinálok, hogy ha x és y a két összeszorzandó szám, akkor úgy írom fel őket, hogy x0+x1ε és y0+y1ε. A szorzatuk:
x0y0+(x0y1+x1y0)ε+x1y1ε2.
Persze, de (x0y1+x1y0)ε  !=  x0y1ε+x1y0ε
Az első eset túlcsordulás oldalról veszélyesebb, a második pontatlanabb (mert összeadáskor le vannak csonkolva). Te a másodikat írtad fent.

Manitu

Beszél itt valaki assemblyül? Különös tekintettel a MASM dialektusra?

Egy ugrótáblát kellene megvalósítanom inline assambly makrókkal C-ben.

int a[0xff];
int index;

/*
* Random kód, ami feltölti a tömböt a szükséges címekkel, és kiszámolja a megfelelő indexet
*/

__asm {
/*
* And now what?
*/
}

Valószínűleg csak egy JMP utasítás kell a megfelelő paraméterekkel, de az a baj, hogy a szintaktikát sem vágom, és egésznapi guglizás után sem sikerült egy értelmes tutoriált találnom, amivel rávehetném, hogy ugorjon az a[index] által mutatott címre.


Próféta

#75
x86? protected mode? milyen széles az int?

Ezt most elsőre biztos full hibásan írom, de szvsz kiindulásnak valami ilyesmi:

mox ax, a ; remélem itt cím adódik át, ha nem, kell indirekciózni ; esetleg kell [ ] az a köré
add ax, index ; remélem itt meg index változó értéke adódik át; vajon szorozni kell-e indexet sizeof int-tel?
jmp ax ; ez kis mázlival az ax által mutatott címre ugrik; ez így valószínűleg kódszegmensen belüli ugrás, lehet, hogy long jump kéne.
Innen talán már kidebuggolható valami működőre. Vagy ezzel nem segítettem sokat?
Jaj, de régen volt is ez.

Lt. Simoan Blarke

aszonták nekem infós kollegák (helyesbítek: Rage-nek köszönd), hogy:

http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html
http://moonbase.wwc.edu/~aabyan/215/inline.html

legalábbis ez nekem inline assemblynek tűnik, mérőtárs miatt lett meg egyedül az a mérés, én nem vágom :D
In Raid_0 the zero stands for how many files you are going to get back if something goes wrong.

"It's easy to kill someone. Just forget the taste of sugar." - Monster

kikuchiyo

vigyázz, a gcc at&t syntaxot használ, ami tök más, mint a masm.

Próféta kódja úgy ránézésre, hunyorítva elvileg jó lehet, persze mox=mov és ax=eax.
Failure is the default option

Manitu

Quote from: Lt. Simoan Blarke on 2008-02-05, 00:45:46
aszonták nekem infós kollegák (helyesbítek: Rage-nek köszönd), hogy:

http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html
http://moonbase.wwc.edu/~aabyan/215/inline.html

legalábbis ez nekem inline assemblynek tűnik, mérőtárs miatt lett meg egyedül az a mérés, én nem vágom :D
Köszönöm, ezeket én is megtaláltam. Ha a gcc-t használhatnám, én lennék a legboldogabb, de ennek Visual Studioban is fordulnia kell. gcc tudja a computed gotot, oda nem is kellene assembly. Damn' windows users :mad:

Quote from: Próféta on 2008-02-05, 00:39:45
x86? protected mode? milyen széles az int?

Ezt most elsőre biztos full hibásan írom, de szvsz kiindulásnak valami ilyesmi:

mox ax, a ; remélem itt cím adódik át, ha nem, kell indirekciózni ; esetleg kell [ ] az a köré
add ax, index ; remélem itt meg index változó értéke adódik át; vajon szorozni kell-e indexet sizeof int-tel?
jmp ax ; ez kis mázlival az ax által mutatott címre ugrik; ez így valószínűleg kódszegmensen belüli ugrás, lehet, hogy long jump kéne.
Innen talán már kidebuggolható valami működőre. Vagy ezzel nem segítettem sokat?
Jaj, de régen volt is ez.
Of course, x86, protected mode, 32 bit.
Én is az értékátadással szívtam, akárhogy variáltam szögleteszárójellel, offsettel, ptr-el, sose azt adta át, ami nekem kellett volna :( Konstanssal sikerült már megcímezni a tömböt, de változóval nem akar összejönni. Azért köszönöm neked is.


Próféta

Quote from: Manitu on 2008-02-05, 01:12:07Én is az értékátadással szívtam, akárhogy variáltam szögleteszárójellel, offsettel, ptr-el, sose azt adta át, ami nekem kellett volna :( Konstanssal sikerült már megcímezni a tömböt, de változóval nem akar összejönni.
Akkor
mov ecx, index
mul ecx, SIZEOF int
add eax, ecx

a középső sor helyett?

Itt biztos vannak mintakódok: http://msdn2.microsoft.com/en-us/library/5sds75we.aspx

Amúgy mire kell?
Függvénypointerek tömbje nem oldja meg?
Vagy gcc-vel lefordítod a kérdéses részt, és linkeled?

Manitu

#80
Quote from: Próféta on 2008-02-05, 01:42:04
Vagy gcc-vel lefordítod a kérdéses részt, és linkeled?
Ezt a gányolást csak nagyon végső esetben alkalmaznám.
Függvénypointer nem jó, a jelenlegi kódban egy többezer soros switch van, azt kellene lecserélni valami gyorsabbra. Ha sikerülne megcsinálni, akkor pont egy függvényhívást, és a switchet spórolnám meg. Szóval a sebesség lenne a lényeg. Egy disassembler-szerűségről van szó egyébként.

Quote from: Próféta on 2008-02-05, 01:42:04
Itt biztos vannak mintakódok: http://msdn2.microsoft.com/en-us/library/5sds75we.aspx
Vesszek meg, fölforgattam az egész msdn-t valami ilyesmi után, de nem találtam meg. Leköteleztél :hail:



Edit:
Quote from: Próféta on 2008-02-05, 01:42:04
Quote from: Manitu on 2008-02-05, 01:12:07Én is az értékátadással szívtam, akárhogy variáltam szögleteszárójellel, offsettel, ptr-el, sose azt adta át, ami nekem kellett volna :( Konstanssal sikerült már megcímezni a tömböt, de változóval nem akar összejönni.
Akkor
mov ecx, index
mul ecx, SIZEOF int
add eax, ecx

a középső sor helyett?
És valóban ez volt a megoldás. Mire leesett, hogy egy sorban csak egy változót tud lekezelni a fordító :redface: De a lényeg: úgy tűnik működik. Mégegyszer köszönöm a segítséget.


Lt. Simoan Blarke

(Előző post out-of date, törölve)

Need c++ grafikus ALGORITMIKUS help. Adott nekem egy olyan feladat, hogy NURBS-szal ki kéne rajzolnom egy Sz-t, Catmull-Clark-kal egy G-t. Namost. a NURBS algoritmusát úgy ahogy van nem értem. A Catmull-Clark-é már so-so, de ami leírás van róla wikipedián, annak alapján ez arra való, hogy egy térbeli objektum felületének a simaságát állítgassam vele. Hátde wtf, most csináljak egy G formájú hurkát? Kábé rohadtul nem értem mit kezdjek a C-C-vel egy G betű görbénél.

A konkrét feladat:
Írjon programot, amely a monogramját a képernyõre rajzolja tetszõleges színnel! A háttérszín a rajzolási szín komplementere, azaz amellyel keverve fehér színt kapunk. A vezetéknévhez NURBS görbét, a keresztnévhez Catmull-Clark felosztott görbét alkalmazzon! Ha a felhasználó az egér bal gombjával a képre bök, a görbék simaságát növelje! Ha a jobb gombbal bökne a képre, akkor csökkentse!

A második kérdés má az lenne ezek után, hogy glut-tal hogy kell rajzolni a képernyőre, de szerintem abban a NeHe már segíteni fog.
In Raid_0 the zero stands for how many files you are going to get back if something goes wrong.

"It's easy to kill someone. Just forget the taste of sugar." - Monster

Kvikveg

Jajjajaj. Tanultam jo regen Spline-gorbekrol, de mar mindent elfelejtettem.
Ha segit: http://mathworld.wolfram.com/NURBSCurve.html
WARNING: module "coffee.exe" did not run correctly. Brain running in limited mode.
Do not meddle in the affairs of dragons for you are crunchy and taste good with ketchup.

Próféta

Emlékekben turkálva: nem volt a Catmullnak valami 2D görbékre való változata is? Nekem így rémlik. Ha nem, akkor bocsi. De úgy kéne működnie, hogy kábé G alakban felveszel egy törtvonalat, aztán az algoritmus majd szépen kisimítja.

NURBS-nál meg nyilván az a feladat, hogy vezérpontokat veszel fel kábé SZ alakban, és utána görbéket illeszt rájuk az algoritmus. A NURBS-ről mit magyarázzunk? Biztos elsütötték órán azt, ahogy a súlyfüggvényeket lépésről lépésre egybemossa, úgy lehet megérteni. Aztán programból meg nyilván nem így csinálod, az együtthatók rekurzív számítása a Kvikveg által linkelt oldal B-spline címszavánál megtalálható; indítasz egy ciklust t=0-tól t=1-ig mondjuk 0.0001 lépésközzel, minden t-re kiszámolod a bázisfüggvényeket ezzel a módszerrel, és velük súlyozva átlagolod a kontroll pontokat, és az így kapott pont a görbe következő pontja.

Lt. Simoan Blarke

Én ebből tanultam, amik itt vannak. Mondjuk mi ezt zhn is használhattuk. Mindenesetre sztm elég tömör és korrektül használható. Ha ez kevés, olvass hozzá API dokumentációt.
In Raid_0 the zero stands for how many files you are going to get back if something goes wrong.

"It's easy to kill someone. Just forget the taste of sugar." - Monster

chilip

#85
ADA-ba kéne egy kis segítség nekem, csomaggal nem boldogulok. nem fogadja el az "in out"-ot a tömb definiálásánal, ha meg kiveszem hiányolja teljesen érthető indokok miatt.

a kód így néz ki:
[spoiler]
Code (kupac.adb) Select
WITH Text_IO, Ada.Integer_Text_IO, kupac_csomag;
USE Text_IO, Ada.Integer_Text_IO;

PROCEDURE Kupac IS
   N, I: Integer := 0;

BEGIN
   Put("Add meg a tomb elemszamat: ");     
   Get(N);
   DECLARE
      -- TYPE TOMB IS ARRAY (1 .. N) OF Integer;
      T: TOMB;     
   BEGIN
      WHILE I /= N LOOP
         I := I + 1;
         Put("Add meg a tomb ");
         Put(I,3);
         Put(". elemet: ");
         GET(T(I));
      END LOOP;
      Rendez(T, N);
   END;
   
END Kupac;

Code (kupac_csomag.adb) Select
WITH Text_IO, Ada.Integer_Text_IO;
USE Text_IO, Ada.Integer_Text_IO;

PACKAGE BODY Kupac_Csomag IS

   FUNCTION Suly ( T : TOMB;
         U,
         V : Integer)return TOMB is

      L : Integer := 1; -- integerben kifejezett igazságérték 0/1
      H,
      Q,
      W : Integer := 0; -- Q, W a CSERE 2-höz kell
   BEGIN
      WHILE 2*U <= V AND L=1 LOOP
         IF 2*U+1 > V OR T(2*U) > T(2*U+1) THEN
            H := 2*U;
         ELSE
            H := 2*U+1;
         END IF;
         IF T(U) >= T(H) THEN
            L := 0;
         ELSE
            Q := T(U);             -- CSERE 2 eleje
            W := T(H);
            T(U) := W;
            T(H) := Q;             -- CSERE 2 vége
            U := H;
         END IF;
      END LOOP;
      RETURN(T);
   END Suly;
   FUNCTION Rendez (
         T : TOMB;
         N : Integer)
         RETURN TOMB IS
      Z : Integer;
      R, X, Y : Integer;
   BEGIN
      IF N = 1 THEN
         Put("Kupacrendezve: ");
         Put(T(1),4);
      ELSE                         -- KHEAP kezdése
         Z := N/2;
         WHILE Z >= 1 LOOP
            Suly(T, Z, N);
            Z := Z-1;
         END LOOP;                 -- KHEAP vége
         R := N;
         WHILE R >= 2 LOOP
            X := T(1);             -- CSERE 1 eleje
            Y := T(R);
            T(1) := Y;
            T(R) := X;             -- CSERE 1 vége
            Suly(T, 1, R-1);
            R := R-1;
         END LOOP;
      END IF;
      RETURN(T);
   END Rendez;
END Kupac_Csomag;


Code (kupac_csomag.ads) Select
PACKAGE Kupac_Csomag IS
   TYPE TOMB IS ARRAY (1 .. N) OF Integer;
   FUNCTION Rendez(T : TOMB; N : Integer) RETURN TOMB;
   FUNCTION Suly(T: TOMB; U, V : Integer) RETURN TOMB;
END Kupac_Csomag;
[/spoiler]

kupacrendezésről (heap) van szó.

kupac.adb-ben kikommenteltem a tömb definíciót, mert azt elvileg a csomag specifikációjában kell megadni. ezenkívül asszem még a with és use def.-eket használtam feleslegesen a kupac_csomag.adb-ben mert egyszer sírt hogy put miatt.

Lt. Simoan Blarke

szarul paraméterezted (legalábbis annak alapján, amit én az ADA-ról tudok).

én úgy tudom (bár mi ADA83-as kódokkal dolgozunk), hogy minden paraméternél le kell írnod, hogy milyen, a paraméterlistában. Pölö (topsecret sourcekód-részletek következnek, vigyázz: :D )

function Cvt (Data : in Dico_Base.T_Enu_Traffic_Direction)
                 return Zc_Database.T_Enu_Direction is

function Next_Block (Blk_Idx : in Dico_Base.T_Block_Idx;
                         Blk_Dir : in Dico_Base.T_Enu_Traffic_Direction;
                         Pt_State : in Dico_Base.T_Enu_Point_Filtered_State) is

procedure Concatene_Message
                 (Appli_Message : in Smartio_Types.T_Rec_Appli_Message;
                  Rec_Message : in out Smartio_Types.T_Rec_Appli_Message) is


stbstb.
In Raid_0 the zero stands for how many files you are going to get back if something goes wrong.

"It's easy to kill someone. Just forget the taste of sugar." - Monster

chilip

#87
he?  :wtf: ez az első szemeszterem ADA-val és pont eggyetlen óráról hiányoztam, amikor a csomagokat vettük  :falba: vettem egy könyvet, de abba nincsenek jó példák a csomagra (tul. képp nincs példa tömb kezelésre csomagban, főként specifikáció kellene) asszem mi ADA 95el dolgozunk...

Lt. Simoan Blarke

#88
Quote from: chilip on 2008-04-08, 15:09:07
he?  :wtf: ez az első szemeszterem ADA-val és pont eggyetlen óráról hiányoztam, amikor a csomagokat vettük  :falba: vettem egy könyvet, de abba nincsenek jó példák a csomagra (tul. képp nincs példa tömb kezelésre csomagban, főként specifikáció kellene)
Pillanat, előtúrom neked azt a 16 oldalas doksit amiből minket készítettek melóra (bár nekünk ezt nem írni, hanem érteni kell). Mindenesetre amire céloztam, hogy a procedure/function paraméterezésnél ott kell lennie az in/out/in out kulcsszónak, majd a felsorolást lezáró zárójel után egy esetleges returns lófasznak. Utóbbira példa:

function Mittomen (Data : in package_neve.változó_típusának_neve;
Data2: in out package_neve.változó_típusának_neve; ) returns package_neve.változó_típusának_neve is

Egyébként ez a package szerinti változó-hivatkozás is hiányozni tűnik nálad.
In Raid_0 the zero stands for how many files you are going to get back if something goes wrong.

"It's easy to kill someone. Just forget the taste of sugar." - Monster

chilip

#89
jaaaa, megnézem, de sztem vágom mire gondolsz... mingyá megnézem...

ed.: basszus rossz helyre irtam az in/out/in out-ot , de még így is több sebből vérzik, sztem ebből a tárgyból "következő szemeszter lesz"...