- Fotók, videók mobillal
- Nothing Phone (3a) és (3a) Pro - az ügyes meg sasszemű
- Huawei Mate X6 - keleti oldal, nyugati oldal
- Telekom mobilszolgáltatások
- Mobil flották
- iPhone topik
- Nem lett arányos a fogyókúra
- Ilyen lesz a Fairphone 6
- Redmi Note 9 Pro [joyeuse]
- Csíkszélességben verné az Exynos 2600 a Snapdragon 8 Elite 2-t
-
Mobilarena
Új hozzászólás Aktív témák
-
proci985
MODERÁTOR
válasz
pmonitor
#20295
üzenetére
(na akkor kiadom magambol, ha mar csinaltam rajta code reviewet megnezni, hogy mi a baj)
ok raneztem bovebben a kodra, szoval ez egy
ListMyHashSet<T>nek, majd hogy ugy tunjon, hogy ket parametert hasznal, kreal egyPointclasst. szoval ez szep meg jo, csak koze nincs a Sethez.mondjuk vannak szepsegek, ez a sor
if (list.Count != Count) list = new List<T>(this);
sor miatt semmit nem csinal, es ha nem lenne korabban a list inicializalva, akkor ennek hibat kene dobnia (hacsak C#nal nincs auto init listre mostanaban. Javaban ez a megoldas NullPointerExceptiont dob mert nem mukodik rendesen a vedelem, bar lehet compilation errort dobna, mert egyertelmuen elerhetetlen a kod, mivel a list. Count es a Count valtozo egy es ugyanaz ebben a kontextusban, Javaban meg erre par eve van automatikus check).reg lattam ennyire olvashatatlan kodot egyebkent. minden valtozo public / auto scope, hasonlo naming conventionert meg ahol en vegeztem az elso eves OO kurzuson mar automatikus fail jart (akkor is, ha a program egyebkent mukodott): nem azt csinalja a class mint amit a neve alapjan elvarnank, C style iterator inicializacio (nem hibas, de balesetveszelyes), magyar valtozonev (torl), roviditett valtozonev (torl), inkonzekvens valtozonev (myPt egy listanak?), inkonzekvens class scope valtozonevek (X, Y).
egyebkent minel tovabb nezem, annal szornyubb.
-
coco2
őstag
válasz
pmonitor
#20277
üzenetére
És melyik része nem volt érthető? Aki nem versenybe szállni akar, csinálhat, amit csak jól esik, a kutya se fogja szekálni. Versenyterepen viszont azonnal a torkának fognak esni olyan népek, akik a sok eszükre talán nem vágnak fel, de őt egészen apró darabokra akármikor, akárhol, és nagyon szívesen. Nincsen másként az egyik szakmai világban sem, az IT-ban sem.
-
pmonitor
aktív tag
válasz
pmonitor
#20198
üzenetére
Senki nem kötött bele ebbe? Így lehet átvágni az olyanokat, akik nem tudnak asm-ben debuggolni!
Ugyanis a "típus jellemzői" nem létezik.
Tehát az osztály úgy épül, hogy a referencia a típus azonosítóra mutat. Majd ezt követik az adattagok. A típus azonosító x86 esetén egy int. Tehát referencia típus esetén az első adattag memóriacíme a típus azonosító memóriacíme utáni byte címe(tehát az offset = 4 byte).
Érték típus esetén nincs típus azonosító! Az érték típus memóriacíme megegyezik az első adattag memóriacímével(tehát az offset = 0 byte)! -
-
nyunyu
félisten
válasz
pmonitor
#20189
üzenetére
Nem teljesen értem, hogy miért akarnál egy magas szintű nyelvről szóló könyvtől gépi kód oktatást várni.
C# az gyakorlatilag egy modernizált C++, amit a Java konkurensének szántak.
Könnyen, gyorsan, biztonságosan fejlesszünk benne alkalmazásokat a lényege, nem az, hogy teljesítmény legyen, mint az alacsony szintű nyelveknél (ASM, valamelyest a C) -
nyunyu
félisten
válasz
pmonitor
#20136
üzenetére
De pl az önkiszolgáló kasszák esetén sem értem, hogy miért nem jutott senkinek az eszébe az, hogy legkésőbb a nyugta nyomtatása előtt árucikkenként összesítenék a darabszámot. Csak ezzel mennyi papírt meg lehetne takarítani országosan? Hozzáteszem, hogy ezt nem csak az önkiszolgáló kasszákra, hanem a hagyományos pénztárakra is lehetne alkalmazni. Összefutottam olyan pénztárossal is, aki 14 darab táblás csokit egyesével csippantott le(úgy, hogy én 2 x 7 - es sorba készítettem elő neki). Na, aaz ilyeneket is kiszűrhetné a program. Azért nem mind1, hogy 14 sorba nyomtatja ki a gép, vagy max. 2 sorban.
Ennek nagyon egyszerű oka van: pénztárgép és taxaméter rendelet.
Ez kellően szőrszálhasogató módon specifikálja egy pénztárgép minden műszaki, funkcionális aspektusát, nyugta, számla tartalmát, kinézetét.
Alapvetés: ami egyszer bekerül az adóügyi egység memóriájába, az utólag már nem módosítható, maximum stornózni tudod, de az új tétel, ellentétes árral
Alapvetés2: nyomtatót, vevőkijelzőt az adóügyi egység vezérli, nem kötheted direktben a számítógépre, pláne nem vezérelheted a saját fejed szerint.Nem tudom most milyen adóügyi egységet használnak az áruházak, mivel utoljára 15 éve foglalkoztam ezzel.
Mi anno a BBOX Pocok4 aztán Pocok8 modulját illesztettük az éttermi szoftverünkhöz. (Auchan akkoriban még az eJournal nélküli, 2 példányos mátrixnyomtatós Pocok2-t használta)Ez nagyon leegyszerűsítve úgy működött, hogy soros porton etetted parancsokkal:
- nyugta nyitás: új nyugta generálása, ekkor kinyomtatta a nyugta fejlécet a kötelező elemekkel (bolt neve, telephely címe, cégnév, cég székhelye, dátum, nyugta szám...)
- új tétel: megadtad a tétel nevét, darabszámát, mennyiségi egységét, egységárát, ÁFA kulcsát (A-E) ekkor letárolta a zárolt memóriába és kinyomtatott egy sort.
- ha rontottad, akkor tétel stornót kellett küldeni negatív árral, ez új tételként jelent meg a memóriában, és ismét kinyomtatott egy sort.
- ha végeztél, akkor nyugta zárás parancs, itt megadtad a fizetésmódot (KP, bankkártya, utalvány... Milyen címlet), ekkor összeszámolta az ÁFA kulcsonkénti részösszegeket, végösszeget, visszajárót és a nyugta lábléccel együtt kinyomtatta, valamint lezárta a memóriában a nyitott nyugta rekordot.De ez még az online pénztárgép című őrület 2012-es bevezetése előtt volt, de gondolom a mostani műszaki követelmények is hasonló működési módot írnak le, csak a sallangok változtak. (Pl. nem kell éves zárást nyomtatni, és papíron vagy az éves eJournalt pénztárgép szervizzel CDre kiíratva leadni a NAVnak, hanem az online cucc úgyis lejelenti nyugtánként, legkésőbb a napi zárásnál az integrált mobilneret használva
Vagy 2005-ben még csak 5000 napnyi/műszaknyi nyugtát kellett tudnia eltárolnia egy adóügyi egységnek, 2009 körül ezt 10000-re duplázták, mostani online verzió már 20000 napnyi memóriát követel, közben meg 3-5 évente kidobatják a hardvert új jogszabályi követelmények miatt
Pl. 2006-ban levizsgázott Pocok4-es rendszerünk 2009-ben már nem kapott engedély hosszabbítást, mert "kevés volt a memóriája", cserélhettük mindent Pocok8-ra.
5 év alatt, ha napi 3x van műszak váltás a 24/7-ben működő bolt/benzinkút pénztáránál, az 5x365x3=5475 napzárás.
Átlag sarki boltban évente 300-365 napot zárnak, simán elketyegne 8-10 évig is egy 5000 napos adómemória, mielőtt cserélni kéne benne az epoxival kiöntött EPROMot, de akkor sem a komplett vezérlő egységet...)Eredeti kérdésedre visszatérve:
Program valószínűleg azt csinálja, hogy vonalkód lehúzásnál automatikusan küldi a vonalkódhoz rendelt terméknevet, mennyiséget (1db), egységárat, ÁFAkulcsot új tételként az AEE-nek, aminek nincs mérlegelési lehetősége, új sorban nyomtatja.Másik megoldás az lenne, hogy a pénztáros kiválasztja a terméket, megnyomja a mennyiség gombot, tapiképernyőn bepötyögi/mérleggel leméreti a mennyiséget, aztán enterrel zárja, és ekkor kerülne át a termék neve, ára, pontos mennyissége, egységára, ÁFA kulcsa az AEE-be.
(Pékárú vagy a gyümölcs így működik az önkiszolgáló kasszáknál, amikor rádobod a 3 almát a mérlegre, aztán kiválasztod, hogy jonatán.)De sokkal gyorsabb 7 csokit egyesével áthúzni a vonalkódolvasón, mint a mennyiség gombbal babrálni az érintőképernyőn, meg nem kell a pénztárosnak ide-oda fordulnia közben.
Aldi/Lidl kaliberű cégeknél meg komolyan mérik a pénztárosok gyorsaságát, hány vásárlót szolgálnak ki óránként.
Így náluk fel sem merül, hogy ezzel nyugtánként 3-5-10 centi papírt pazarolnak, lényeg az, hogy hárommal több vásárlót préseljenek át a pénztáron óránként, annyival kevesebb pénztárost kell fizetni.
(Már rég nem néztem, mennyi most egy pénztárgépekbe való 80mmx80m-es hőpapír. 500Ft/guriga? az 500/80 = 6,25Ft/méter.
Nyugtánként 10 centi papír felesleg az 62,5 fillér.) -
kovisoft
őstag
válasz
pmonitor
#20154
üzenetére
Az asm program az inputot kapja mondjuk az stdin-ről. Ez lehet a user által éppen begépelt adat, de lehet egy file-ba már előzetesen beírt adat is, aminek a tartalma pipe-olva van az asm program stdin-jébe. Tehát ezen logika alapján az első esetben nem rendezést végez az asm program, hiszen az adat még nem létezik a program indulásakor. A második esetben viszont rendezést végez, hiszen a rendezendő adat már létezik egy file-ban a diszken. Érdekes megközelítés lenne, főleg, hogy amúgy mindkét esetben maga a program ugyanazt csinálja.
-
axioma
veterán
-
kovisoft
őstag
válasz
pmonitor
#20150
üzenetére
Természetesen ez is rendezés, mégpedig beszúrásos rendezés. Nincs olyan definíció, hogy egy rendezésnél a rendezendő lista vagy tömb teljesen ott kell legyen a memóriában, mielőtt elindulna a rendezési folyamat. Ellenkező esetben pl. nem beszélhetnénk rendezésről olyan esetben, amikor akkora fájlt kell rendezni, ami nem is fér el egyszerre a memóriában, azaz csak részenként, több menetben hajtható végre.
-
axioma
veterán
válasz
pmonitor
#20148
üzenetére
Es az mi ha nem sorbarendezes? Attol h menet kozben csinalod, pont ugyanaz az ido- es kodolasi igeny [kiveve olyan nyelvekben, ahol a kesz tombre meghivod a sort-ot, ott rosszabb.]
Raadasul megint az inputtal foglalkozol, a megoldasresz ettol nem lesz ujrafelhasznalhato, nem eleg altalanos.
Ha a gyakorisagos megoldast mondtad volna, az otletes, es idohatekony [tarhelyben viszont mas, nagy konstans a linearis helyett]. Me'g az is lehet, h asm-ben kevesebb kod, es az egymasba agyazott ciklus kihagyasaval kovethetobb is. Persze az is csak 'jo' inputtipusokra fog mukodni - de legalabb valami elonyert cserebe.
Ez is, marmint a megoldas altalanossaga egy olyan tetel, ami miatt szoftverfejleszto es kodgyarto kozott kulonbseg van. Big picture kell, egy hazinal is, abbol alakul majd a modul/projektszintu, stb. -
axioma
veterán
válasz
pmonitor
#20143
üzenetére
Most oszinten, szerinted ebben a haziban az 1..1000 a kulcs, vagy az csak tesztadat, a lenyeg az altalanosan mukodo algo? Igen, gyakorisag-tablaval gyorsabb, de az ritka esetben [viszonylag alacsony darabszamu es elore ismert ertekkeszlet] hasznalhato. Erdekessegkepp meg lehet azt is irni, de en valoszinutlennek tartom, hogy arra gondolt a kolto [tanar].
Kieg. a pivot = 500-zal is lehetne trukkozni, de egyreszt azt az algot kodolni/atlatni nehez, es nincs erdemi oktato jellege. -
coco2
őstag
válasz
pmonitor
#20131
üzenetére
Igen, a kicsit kevésbé politikailag korrekt változat úgy szól, hogy akár kard, akár szavak, mindkettővel az erősebb győz - és még mindig keresem az idézet eredeti forrását, de nem találom
A magam részéről a szólás szabadság hiányát a jelenlegi helyzetben inkább tünetnek mondanám, mint alap problémának. Az alap probléma, hogy a népek el vannak tévedve a demokrácia és a szólás szabadság alapjairól. Főleg, mert nem tanultak történelmet. Róma a rablógyilkosok társadalma volt. És az a demokrácia bölcsője. Ahhoz képest a programozók "puhák".
Azt a problémát akár csak elkezdeni kiiktatni kommunikációs központként minimum egy militáris fórum kellene. Ha lenne fórum szoftveres eszközöket militáris célra használni, konkrétan ember társaink kiírtására, abban a fórumban aligha lehetne belefolytani a szót a tényekbe. Nem passzolna a hangulat.
Namost itt a PH-n ugyan nem kérdeztem meg a modikat, de szerintem a militarizmusnak nem fognak helyet adni. Most még nem.
-
coco2
őstag
válasz
pmonitor
#20128
üzenetére
>De az sztem. a programozók felelőssége kellene, hogy legyen, hogy fel'homályosítsák az ügyfelet(ebben az esetben az üzletet) a kockázatokról.
Reagálnék csak erre az egyre.
A legtöbb olyan alkalmazást, amit nagyobb cégek a jelenben használnak, általában olyan környezetben írják, ahol a programozó a száját nem meri kinyitni, mert nem csak kirúgni fogják, hanem a főnöke élve és nyersen eszi meg ott helyben - akár a rendőrség szeme láttára.
És akkor te jönnél a programozók felelősségével? Hát nem. A feltételezést is elutasítom. Szerintem a programozónak nincsen azon felelőssége.
-
pmonitor
aktív tag
válasz
pmonitor
#20128
üzenetére
Ebben a könyvben pontosan a felelősségről van szó. Ha nagyon röviden akarom leírni a tartalmát, akkor a következőt mondanám: A profi programozót az különbözteti meg a kezdőtől, hogy a profi programozó felelősséget kell, hogy vállaljon a munkájáért.
Ezzel kapcsolatos az alábbi programom. Kaptam 1 e-mailt, hogy:
szeretném használni a MyCutters
kódott.
Ami eddig nagyából sikerül is.A probléma akkor van ha az
alkatrész méret és darabszám párosból több van mint 25. Erre
van megoldás kérem ossza meg velem.
Előre is köszönöm.Hozzá kell tennem, hogy a programom teljesen ingyenes. Ettől függetlenül(ha nem is azonnal, de) természetesen foglalkozni fogok a dologgal. Csak előbb inkább át szeretném írni a kódot. OOP baráttá szeretném tenni a kódot(mert jelenleg nem az).
-
coco2
őstag
válasz
pmonitor
#20124
üzenetére
Van biztonsági őr, aki figyel. Ha olyat próbálsz csinálni, hogy nem húzol le egy terméket, rád szól.
Amit megtehetsz, hogy a zöldséges pultnál lemért banánért kapott címkével felül ragasztod a PS4 címkéjét, és úgy húzod le. Az aligha fog feltűnni az őrnek. De nem lehúzni valamit az gáz.
@VikMorroHun
Hogyan bukott le, aki a fenti viccet eljátszotta?
-
axioma
veterán
válasz
pmonitor
#20121
üzenetére
Ez a te nezeted. Mondok egy eletszerubbet: megbizo hataridore akart valami mukodot, nem baj ha nem tud mindent de tegnapra. POC is jo lesz. (Vagy csak elfelejti belerakni a specifikacioba. Vagy feltetelezik, hogy majd ugyis felviszik a dolgozok a gyujtocsomagolasnak a vonalkodjat is. Vagy... vagy...) Ez kimegy, aztan mar nem erdekuk frissiteni [ertsd: ujra fizetni a plusz meloert es az uj delivery folyamatert] amig mukodik.
Bar sztem auchan regen n-szer huzgatos volt, most meg mar megy a szorzas, szoval van ellenpelda.Amugy veletlen nincs a ket aruhazlanc kozott olyan kulonbseg is, hogy az egyiknek van merlege, a masiknak nincs az aruk atpakolasanal? Nem mind1...
Ez nem programozasi kerdes, hanem uzleti. Nyilvan aki csinalta tudna JPE bevetessel jobbat csinalni, de ez nem jelenti azt, hogy az adott projektben ezt meg is csinalhatta.
-
#20122
VikMorroHun
őstag
pmonitor
#20119
VikMorroHun
őstag
-
pmonitor
aktív tag
-
pmonitor
aktív tag
válasz
pmonitor
#19936
üzenetére
Egy kicsit összetettebb példakódot is írtam. A leírás itt található. A példa kód pedig itt.
Ezen világosan látszik a típusok címzése különböző típusok esetén.
-
pmonitor
aktív tag
válasz
pmonitor
#20039
üzenetére
Jaaa. Meg még meg is figyelnek. Illegális felvételeket készítenek rólam. De ugye én paranoid szkizofrén vagyok, úgyhogy lehet, hogy csak beképzelem?? Csak ugye ez mellett még van parkinzonizmusom, szorongással kevert depresszióm is. Ki tudja? Majd csak kiderül valamikor, hogy csak képzelődöm-e a megfigyeléssel kapcsolatban...
-
pmonitor
aktív tag
válasz
pmonitor
#20029
üzenetére
Azért gondolj bele: én "megtalálható" vagyok, mert nyilvánosságra hoztam az adataim.
Megtalálható vagyok, de ettől még nem csinálom össze magam. Ami a véleményem a fórumozó "programozókról", azt személyesen elmondom bárkinek. Csak vannak, akik az ember háta mögött szervezkednek. Persze ők is név nélkül.... A háttérben.
-
válasz
pmonitor
#20035
üzenetére
Ha ezt a nebulók olvasták, akkor nem tudom, hogy kit szidnak, hogy őket meg ezekkel a vezérlési szerkezetekkel szívatják. És még meg is buknak, ha nem csinálják...
Szerintem félreérthető voltam. Egy munkahelyről beszéltem, ahol alapnak veszik, hogy a belépő kolléga ezeket ismeri. Az egyetemen nyilván buktatnak azért, ha még ezt se ismered. -
válasz
pmonitor
#20023
üzenetére
Most speciel nem hülyeség, amit kapizsgálsz. Ettől függetlenül sajnos de, kőkemény tudás kell, mert hiába húzol be rengeteg libet, attól még vannak specifikus fejlesztési feladatok. Ezek egy részét kikönnyítik a külső modulok, de azok megismerése is időt/tudást igényel.
Ez nem mond ellent annak, amit a kolléga írt, sőt! Ő arról beszélt, hogy senki sem ír már meg 0-ról mondjuk egy CRM rendszert, mert nem rentábilis/hülyeség. Ettől függetlenül az üzleti logikákat implementálni kell. Csak mondjuk egy SSO-ra bízzák a jogosultság kezelést, mert tök felesleges ezt is házon belül megvalósítani, van rá a piacon több stabil, kiforrott megoldás is. Ugyanez igaz mondjuk a networkre, securityre, franc se tudja még mikre.
Enterprise környezetben még az is piszok nehéz, hogy millió korlátot kell figyelembe venni. Egyrészt már mindenhol domain szemlélet van. Nem az van, hogy csak odatoszod a kódot, ahova akarod, kőkeményen szervezve van domainek szerint, ami amúgy újabb megoldandó problémákat szül.
Összefoglalva: a mezei, klasszikus programozó feladatok átalakulnak (itt többen is utaltak rá). Ma már nyilván nem az a kihívás, hogy jó vezérlési szerkezetet írjál, hanem hogy ismerd a framework lehetőségeit/korlátait, értsd és betartsd a vállalati patterneket, jól átlásd a business feature-t, stb. És akkor még nem beszéltünk a devops szemlélet meghonosodásáról, CI/CD problémákról, amik már ugyanúgy fejlesztői feladatok.
-
#19975
hiperFizikus
senior tag
pmonitor
#19974
hiperFizikus
senior tag
válasz
pmonitor
#19974
üzenetére
" Python izomzat "
-
pmonitor
aktív tag
válasz
pmonitor
#19909
üzenetére
biztos vagyok benne, hogy nem a publikus kódokat fordítják élesben
Hát... Egyre biztosabb vagyok benne. Ennek a file-nak a 197-es sorában levő __asm kulcsszó úgy tudom, hogy már régen nem létezik. Az asm részeket külön file-ban kell létrehozni. Tehát úgy néz ki, hogy az is egy átverés, hogy ez az éles open source.
-
sztanozs
veterán
válasz
pmonitor
#19941
üzenetére
My bad, igazad van.
Ez valojaban csak egy nyelvi magia (pixiedust), hogy a nyelvi struktura is megmaradjon, de az interpreter se dogoljon bele a felesleges munkaba.
Az oroklodes (System.Object -> System.ValueType ... es onnan a struct es a primitivek) azert van, hogy a nyelvi elemeket megkotes nelkul lehessen hasznalni az ertek tipusokta (primitivek) es a "teljes" osztaly tipusokra. -
-
pmonitor
aktív tag
válasz
pmonitor
#19935
üzenetére
Röviden:
A struct gyakorlatilag azt jelenti, hogy a változót "HELYBEN" hozza létre.
A class azt jelenti, hogy a változót mindig a heap egy szabad területén hozza létre.Van ez a C# kód:
namespace IntOseEAzObject
{
public class Program
{
static void Main(string[] args)
{
int[] lngt = { 10, 20, 30 };
Struktura strct = new Struktura(10, 20, 30, lngt);
long lng = strct.lng;
int lng_2 = strct.lng_2;
int lng_3 = strct.lng_3;
int lng_4 = lngt[0];
int lng_5 = lngt[1];
int lng_6 = lngt[2];
Console.WriteLine("{0} {1} {2} {3} {4} {5}", lng, lng_2, lng_3, lng_4, lng_5, lng_6);
}
}
struct Struktura
{
public int lng;
public int lng_2;
public int lng_3;
public int[] list;
public Struktura(int lng, int lng_2, int lng_3, int[] list)
{
this.lng = lng;
this.lng_2 = lng_2;
this.lng_3 = lng_3;
this.list = list;
}
}
}
Ez assemblyben így mutatkozik meg(csak a releváns részt másolom be ide:int[] lngt = { 10, 20, 30 };
011508A5 mov ecx,63F6639Eh
011508AA mov edx,3
011508AF call CORINFO_HELP_NEWARR_1_VC (0107322Ch)
011508B4 mov dword ptr [ebp-70h],eax
011508B7 mov ecx,1084EF4h
011508BC call 65485DE0 ;ez a metódus adja vissza az eax-ban az lngt[] címét.
011508C1 mov dword ptr [ebp-74h],eax
011508C4 lea eax,[ebp-74h]
011508C7 push dword ptr [eax]
011508C9 mov ecx,dword ptr [ebp-70h]
011508CC call 65485A80
011508D1 mov eax,dword ptr [ebp-70h]
011508D4 mov dword ptr [ebp-40h],eax
Struktura strct = new Struktura(10, 20, 30, lngt);
011508D7 push 14h
011508D9 push 1Eh
011508DB push dword ptr [ebp-40h]
011508DE lea ecx,[ebp-50h]
011508E1 mov edx,0Ah
011508E6 call IntOseEAzObject.Struktura..ctor(Int32, Int32, Int32, Int32[]) (01150450h)
long lng = strct.lng;
011508EB lea eax,[ebp-50h]
011508EE mov eax,dword ptr [eax+4] ;Itt mindig az ebp-hez viszonyított helyzethez határozza meg. strct[0] esetén ebp+4
011508F1 cdq
011508F2 mov dword ptr [ebp-58h],eax
011508F5 mov dword ptr [ebp-54h],edx
int lng_2 = strct.lng_2;
011508F8 lea eax,[ebp-50h]
011508FB mov eax,dword ptr [eax+8] ;strct[1] esetén ebp+8
011508FE mov dword ptr [ebp-5Ch],eax
int lng_3 = strct.lng_3;
01150901 lea eax,[ebp-50h]
01150904 mov eax,dword ptr [eax+0Ch] ;strct[3] esetén ebp+12
01150907 mov dword ptr [ebp-60h],eax
int lng_4 = lngt[0];
0115090A mov eax,dword ptr [ebp-40h]
0115090D cmp dword ptr [eax+4],0
01150911 ja IntOseEAzObject.Program.Main(System.String[])+0D0h (01150918h)
01150913 call 656EFE40 ;referencia típus esetén(lngt[0]) mindig ezt a metódust hívja meg, ami az eax-ban adja vissza a referencia címét, ami a heap-ben van. Előtte nem véletleül ellenőrzi le, hogy érvényes-e a cím.
01150918 mov eax,dword ptr [eax+8]
0115091B mov dword ptr [ebp-64h],eax
int lng_5 = lngt[1];
0115091E mov eax,dword ptr [ebp-40h]
01150921 cmp dword ptr [eax+4],1
01150925 ja IntOseEAzObject.Program.Main(System.String[])+0E4h (0115092Ch)
01150927 call 656EFE40 ;lngt[1] esetén is ugyanazt a metódust hívja meg.
0115092C mov eax,dword ptr [eax+0Ch]
0115092F mov dword ptr [ebp-68h],eax
int lng_6 = lngt[2];
01150932 mov eax,dword ptr [ebp-40h]
01150935 cmp dword ptr [eax+4],2
01150939 ja IntOseEAzObject.Program.Main(System.String[])+0F8h (01150940h)
0115093B call 656EFE40 ;lngt2 esetén is ugyanazt a metódust hívja meg.
01150940 mov eax,dword ptr [eax+10h]
01150943 mov dword ptr [ebp-6Ch],eax
Console.WriteLine("{0} {1} {2} {3} {4} {5}", lng, lng_2, lng_3, lng_4, lng_5, lng_6);
01150946 mov eax,dword ptr ds:[483244Ch]
0115094C mov dword ptr [ebp-78h],eax
0115094F mov ecx,63F664BAh
01150954 mov edx,6A kódba magyarázatot is tettem. Érdemes elgondolkodni rajt. Sztem.
-
coco2
őstag
válasz
pmonitor
#19903
üzenetére
Hát pedig a realitás kicsit úgy néz ki, hogy a szakértői munkaóra a legdrágább pontosan azért, amit te is írsz: alig van hozzáértő ember.
Egykoron - az üveghegyeken túl.. bla-bla-bla - még azzal kezdték a tervezést, hogy társadalmi célok, üzleti célok, technikai célok. Azok mind együtt számítottak. Abból a nézőpontból látható tisztábban, hogy mennyire érdemes egy fejlesztés technikai oldalát megcsiszolni. Hogy 2 millió szervert csak arra fognak használni, ergo 10% többlet erőforrás használat per copy naponta fog 200 millió huf-ba kerülni, vagy összesen a mesebeli L'art pour l'art cég besenyő pistabácsijának havonta 1 látogatót kiszolgáló szerverén kell futnia valaminek, ahol az sem gáz, ha rendszeresen bedöglik valami - mert ugyan kit zavar?
Ha már úgyis a minőségi részleteken lovagolsz, ugyan ne legyél egészen szemellenzős szakbarbár.
-
martonx
veterán
válasz
pmonitor
#19903
üzenetére
Pedig bizonyos esetekben tényleg rohadt lényegtelen az app mérete. Mondok egy konkrét példát:
Csinálnod kell egy naponta egyszer ütemezetten futó programot. A szervernek amin fut van 2gb ramja, ebből üres 1.5gb. Üres lemez területe pedig van mondjuk 10gb. A programnak mint mindig, tegnapra kell kész lennie. Ekkor fogsz egy magas szintű nyelvet két nap alatt összerakod, és mondjuk a végeredmény futáskor foglal 50 MB áramot, naponta egyszer mondjuk 2 percen keresztül. A lemezen meg foglal 100mbyte-ot.
Vs. C-ben hetekig csiszolod és a végén futásidőben 1 mbyte ramot foglal naponta egyszer 2 percig, a lemezen meg csak 10mbyte-ot. -
pmonitor
aktív tag
válasz
pmonitor
#19877
üzenetére
Időközben megtaláltam itt a smooth-ot és a boca-t.
Hirtelen megpróbáltam lefordítani a smooth-ot. Az meg mást hiányol. Túl hamar írtam. Hosszabb időt kell ezzel eltölteni...@nemethg66: már írtam, hogy a számítógép nem olvas doksit. Erre jó példa volt az, hogy az int-nek őse-e az object.
Mert amit sztanozs írt, az azt jelentené, hogy pl. az int egyszer értéktípus, máskor pedig referenciatípus. De a kettő kizárja egymást.
-
sztanozs
veterán
válasz
pmonitor
#19843
üzenetére
A problema nem az object/struct miatt van, hanem az unboxing miatt, mivel az egyik objektumod object tipusu, ezert az erteket explicite be-, es kicsomagolod (20., 89. es 93. sor). Ez viszi el a plusz idot, nem a GC:
.method private hidebysig static
void Main (
string[] args
) cil managed
{
.custom instance void System.Runtime.CompilerServices.NullableContextAttribute::.ctor(uint8) = (
01 00 01 00 00
)
// Method begins at RVA 0x2094
// Header size: 12
// Code size: 171 (0xab)
.maxstack 6
.entrypoint
.locals init (
[0] int64 i,
[1] int64 j,
[2] int64 m,
[3] class [System.Runtime]System.Diagnostics.Stopwatch sw,
[4] int64 n,
[5] object k,
[6] int64 p,
[7] bool,
[8] bool
)
// {
IL_0000: nop
// long num = 0L;
IL_0001: ldc.i4.0
IL_0002: conv.i8
IL_0003: stloc.0
// long num2 = 0L;
IL_0004: ldc.i4.0
IL_0005: conv.i8
IL_0006: stloc.1
// long num3 = 0L;
IL_0007: ldc.i4.0
IL_0008: conv.i8
IL_0009: stloc.2
// Stopwatch stopwatch = Stopwatch.StartNew();
IL_000a: call class [System.Runtime]System.Diagnostics.Stopwatch [System.Runtime]System.Diagnostics.Stopwatch::StartNew()
IL_000f: stloc.3
// for (num3 = 0L; num3 < 3000000000u; num3++)
IL_0010: ldc.i4.0
IL_0011: conv.i8
IL_0012: stloc.2
// (no C# code)
IL_0013: br.s IL_0020
// loop start (head: IL_0020)
// num = num3;
IL_0015: nop
IL_0016: ldloc.2
IL_0017: stloc.0
// num2 = num;
IL_0018: ldloc.0
IL_0019: stloc.1
// for (num3 = 0L; num3 < 3000000000u; num3++)
IL_001a: nop
IL_001b: ldloc.2
IL_001c: ldc.i4.1
IL_001d: conv.i8
IL_001e: add
IL_001f: stloc.2
// for (num3 = 0L; num3 < 3000000000u; num3++)
IL_0020: ldloc.2
IL_0021: ldc.i4 -1294967296
IL_0026: conv.u8
IL_0027: clt
IL_0029: stloc.s 7
// long elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
IL_002b: ldloc.s 7
IL_002d: brtrue.s IL_0015
// end loop
IL_002f: ldloc.3
IL_0030: callvirt instance int64 [System.Runtime]System.Diagnostics.Stopwatch::get_ElapsedMilliseconds()
IL_0035: stloc.s 4
// for (num3 = 0L; num3 < 3000000000u; num3++)
IL_0037: ldc.i4.0
IL_0038: conv.i8
IL_0039: stloc.2
// (no C# code)
IL_003a: br.s IL_0053
// loop start (head: IL_0053)
// object obj = num3;
IL_003c: nop
IL_003d: ldloc.2
IL_003e: box [System.Runtime]System.Int64
IL_0043: stloc.s 5
// num2 = (long)obj;
IL_0045: ldloc.s 5
IL_0047: unbox.any [System.Runtime]System.Int64
IL_004c: stloc.1
// for (num3 = 0L; num3 < 3000000000u; num3++)
IL_004d: nop
IL_004e: ldloc.2
IL_004f: ldc.i4.1
IL_0050: conv.i8
IL_0051: add
IL_0052: stloc.2
// for (num3 = 0L; num3 < 3000000000u; num3++)
IL_0053: ldloc.2
IL_0054: ldc.i4 -1294967296
IL_0059: conv.u8
IL_005a: clt
IL_005c: stloc.s 8
// long elapsedMilliseconds2 = stopwatch.ElapsedMilliseconds;
IL_005e: ldloc.s 8
IL_0060: brtrue.s IL_003c
// end loop
IL_0062: ldloc.3
IL_0063: callvirt instance int64 [System.Runtime]System.Diagnostics.Stopwatch::get_ElapsedMilliseconds()
IL_0068: stloc.s 6
// Console.WriteLine("{0} {1} {2} {3}", num2, num3, elapsedMilliseconds, elapsedMilliseconds2 - elapsedMilliseconds);
IL_006a: ldstr "{0} {1} {2} {3}"
IL_006f: ldc.i4.4
IL_0070: newarr [System.Runtime]System.Object
IL_0075: dup
IL_0076: ldc.i4.0
IL_0077: ldloc.1
IL_0078: box [System.Runtime]System.Int64
IL_007d: stelem.ref
IL_007e: dup
IL_007f: ldc.i4.1
IL_0080: ldloc.2
IL_0081: box [System.Runtime]System.Int64
IL_0086: stelem.ref
IL_0087: dup
IL_0088: ldc.i4.2
IL_0089: ldloc.s 4
IL_008b: box [System.Runtime]System.Int64
IL_0090: stelem.ref
IL_0091: dup
IL_0092: ldc.i4.3
IL_0093: ldloc.s 6
IL_0095: ldloc.s 4
IL_0097: sub
IL_0098: box [System.Runtime]System.Int64
IL_009d: stelem.ref
// (no C# code)
IL_009e: call void [System.Console]System.Console::WriteLine(string, object[])
// Console.ReadKey();
IL_00a3: nop
IL_00a4: call valuetype [System.Console]System.ConsoleKeyInfo [System.Console]System.Console::ReadKey()
IL_00a9: pop
// }
IL_00aa: ret
} // end of method Program::MainAz optimalizalt valtozatot nezve jol lahthato a ket "felesleges" utasitas:
// loop start (head: IL_0018)
IL_0011: ldloc.1
IL_0012: stloc.0
vs// loop start (head: IL_003e)
IL_002d: ldloc.1
IL_002e: box [System.Runtime]System.Int64
IL_0033: unbox.any [System.Runtime]System.Int64
IL_0038: stloc.0 -
coco2
őstag
válasz
pmonitor
#19836
üzenetére
A c# struct érték típus. Érték szerint adódik át, és nem referencia szerint. Itt találod az msdn-en a figyelmeztetést:
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/struct
Apropó, unsafe erőforrásokat leszámítva minden a gc felügyelete alá tartozik.
-
sztanozs
veterán
válasz
pmonitor
#19832
üzenetére
Attol meg hogy nem orokol... Inkabb olvasdd el a specifikaciot:
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/structs#1643-inheritanceEs meg:
The common type system
It's important to understand two fundamental points about the type system in .NET:It supports the principle of inheritance. Types can derive from other types, called base types. The derived type inherits (with some restrictions) the methods, properties, and other members of the base type. The base type can in turn derive from some other type, in which case the derived type inherits the members of both base types in its inheritance hierarchy. All types, including built-in numeric types such as System.Int32 (C# keyword: int), derive ultimately from a single base type, which is System.Object (C# keyword: object). This unified type hierarchy is called the Common Type System (CTS). For more information about inheritance in C#, see Inheritance.
[link] -
coco2
őstag
válasz
pmonitor
#19830
üzenetére
>A wav -> mp3 konverzióra is van vmi. értelmes válaszotok?
Bár kissé offtopic, de tessék:
https://cloudconvert.com/wav-to-mp3
A c#-t illetően meg tényleg nincsen igazad. Az egy byte kódos környezet. VM futtatja. Absztrakt minden. Az egyetlen terület, ahol c# kód valódi integert (alias nyers memóriát) kezelhet, unsafe blokk-on belül tud előfordulni. Azon kívül nem.
-
dabadab
titán
válasz
pmonitor
#19815
üzenetére
A ValueType Osztály hogy lenne már érték típus?
Szóval nem sikerült betolni a google translate-be a nevét és azt az egy sornyi kódot se sikerült lefuttatnod, ha már egyszer a dokumentáció elolvasása ("Inheritance Object -> ValueType", "ValueType overrides the virtual methods from Object with more appropriate implementations for value types.") egyértelműen meghaladja a képességeidet. Gratulálok!
-
disy68
aktív tag
válasz
pmonitor
#19810
üzenetére
"Pl. egy magát profinak beállító emberke azt állítja, hogy C#-ban az int őse az object."
mivel igaza is van, dokumentálva is van rendesen
a .net-ben az int ami az Int32 Struct egy ValueType, aminek az őse az Objectde ha annyira kódot szeretnél, akkor tessék:
Assert.IsTrue(typeof(object).IsAssignableFrom(typeof(int))); -
axioma
veterán
válasz
pmonitor
#19810
üzenetére
De te nem egy iskolai oran tanulsz programozast (valoszinuleg raadasul kesobb ezt szakmakent szeretne hasznalni), mint a kerdezo, es lattad a berakott kodjat, nagyon nem latta at az alapokat sem. Sok-sok kerdezessel elorebb jutott volna, most igy csak kesz a hazi, ha akarja nem kell gondolkodnia semmin.
-
.45
csendes tag
válasz
pmonitor
#19761
üzenetére
Általában ha valaki emailben kap reklámot egy bizonyos oldaltól, akkor annak az oldalnak o adta meg a szóban forgó emailcímet. Kivételek persze a klasszikus scam emailek: nigériai herceg, lottonyeremény, stb... De nekem úgy tunik, hogy ebben az esetben ez nem áll fenn. Vagy esetleg már melltartókkal is át lehet verni embereket, ki tudja
-
sztanozs
veterán
válasz
pmonitor
#19687
üzenetére
szvsz nem mondtal el semmi olyat, amit eddig ne tudtunk volna, szoval ez sem tobb barmi rizsanal. Ilyen szivatast gyerekkoromban (amig elt a rossz emleku net send) en is csinaltam azokkal a kollegakkal szemben, akik nem voltak hajlandok leszedni a read receipt-et a leveleikrol.
-
sztanozs
veterán
válasz
pmonitor
#19677
üzenetére
A DLL injection (es DLL hooking) egy szeles korben hasznalt technika nem csak rossz, de hasznos celra ia (ahogy a cikkben a szero az elso mondatban is irja). Az EDR eszkozok termeszetesen nem fognak reagalni minden injection esemenyre, hanem mukodesi parameter alapjan riasztanak. Egy messagebox pedig lassuk be nem tul nagy fenyegetes
-
martonx
veterán
válasz
pmonitor
#19652
üzenetére
Nem, nem, sima phising-et szívott be ott valaki, és még ahhoz is debilek voltak, hogy ne férjen mindenki hozzá mindenhez, így az amatőr hackerek röhögve vihettek mindent. De a hab a tortán az volt, amikor a hosszas kussolás, mellébeszélés után nyilatkoztak, hogy mindent megoldottak, a hackerek meg másnap újabb friss adatokat tettek közzé demonstrálandó, hogy azóta is folyamatosan bent vannak a rendszerben
-
pmonitor
aktív tag
válasz
pmonitor
#19652
üzenetére
Itt van egy konkrét példa arra, amit az előbb írtam. Itt a magát "vérprofinak" nevező elkezdett elméleti dolgokat nézni, amíg én(aki csak egy "programozgató" vagyok a gyakorlatot néztem. Azt, hogy hogy lehet megoldani a feladatot.
-
pmonitor
aktív tag
válasz
pmonitor
#19520
üzenetére
Ja. Még annyit, hogy az én nézetem szerint, ha a programozásban valaki(k) ki akar(nak) tűnni, annak jó mércéje lehet, hogy mennyien támogatják maguktól a kész programot. Mert a pénzbeli támogatásnak nem vagyok ellene. Csak annak, hogy kötelezően meg kelljen venni egy programot.
-
coco2
őstag
válasz
pmonitor
#19448
üzenetére
>2.: ami a jelen előtt max. pár perccel megtörtént.
Az nem biztos. Hazudni is lehet róla.
>Bár coco2 biztos felaprítaná a több mint 3 méteres darabot is. Végül is ez is lehet egy szempont.
Rávilágítani gondoltam, hogyan kezeli a helyzetet a gyakorlat. Mindegy, hogy 1 darabban marad meg 3 méter, vagy 50 darabban. Az ügyfél a processzt kifizette, a maradék kuka, és bármi maradt meg, azt egyformán fogják kezelni. Sajnálom, ha az alkalmazott gyakorlat flegmaságain te besértődsz. Ha attól könnyebb, nevezz ki engem az egész világ főbűnösének. Egészségedre váljék.
-
pmonitor
aktív tag
válasz
pmonitor
#19448
üzenetére
Ezért is írtam ittenke, hogy:
>adományozhatna a kapcsolat oldalon megadott számlaszámra. Ezt 1/3 részben poénnak szántamEzért is szántam az adományozás 1/3 részét poénnak, mert bizonyos szempontból "bohóckodás" ez az egész programozósdi az ilyennel. Attól függ, hogy honnan nézzük. Mondjuk egy programozó nagy valószínűséggel nem mondja ezt. Főleg, ha az adott témában programozik.
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Új hozzászólás Aktív témák
Hirdetés
● olvasd el a téma összefoglalót!
- Fotók, videók mobillal
- Kerékpárosok, bringások ide!
- Egyre csak fejlődik az AI, emberek tízezreit rúgja majd ki a BT
- Nothing Phone (3a) és (3a) Pro - az ügyes meg sasszemű
- Vicces képek
- Huawei Mate X6 - keleti oldal, nyugati oldal
- Telekom mobilszolgáltatások
- Bundle topik
- Autós topik
- Nagyrobogósok baráti topikja
- További aktív témák...
- Eladó konfig! Ryzen 7 7800X3D 2TB SSD 64GB DDR5 RX9070XT 16GB!
- Új, makulátlan állapotú Samsung Galaxy Buds FE, fehér, fél év garancia
- Új, makulátlan állapotú Samsung Galaxy Watch7 44mm ezüst, 2 év garancia
- Új, makulátlan állapotú Samsung Z Fold 6 256GB Tengerészkék, független, 2 év garancia
- Használt TP-Link Deco M4 - AC1200 Router (Mesh-ként is használható)
- LG 27UL550-W - 27" IPS / 3840x2160 4K / 60Hz 5ms / HDR10 / AMD FreeSync
- Bomba ár! Fujitsu LifeBook U757 - i3-7GEN I 16GB I 256SSD I 15,6" FHD I HDMI I Cam I W11 I Garancia!
- Bomba ár! Dell Inspiron 7400 - i7-1165G7 I 8GB I 512SSD I 14,5" 2K I HDMI I Cam I W11 I Garancia!
- BESZÁMÍTÁS! Asus ROG Flow Z13 + ROG XG RTX 3070 - i9 12900H 16GB DDR5 RAM 1TB SSD + RTX 3070 8GB WIN
- Bomba ár! Lenovo ThinkPad T490 - i5-8GEN I 16GB I 256GB SSD I 14" FHD I Cam I W10 I Garancia!
Állásajánlatok
Cég: PC Trade Systems Kft.
Város: Szeged
Cég: Promenade Publishing House Kft.
Város: Budapest