- iPhone topik
- Apple Watch
- A hagyományos (nem okos-) telefonok jelene és jövője
- Samsung Galaxy S25 Ultra - titán keret, acélos teljesítmény
- Fotók, videók mobillal
- Samsung Galaxy Watch (Tizen és Wear OS) ingyenes számlapok, kupon kódok
- Samsung Galaxy S24 Ultra - ha működik, ne változtass!
- Android alkalmazások - szoftver kibeszélő topik
- VoLTE/VoWiFi
- Samsung Galaxy S23 és S23+ - ami belül van, az számít igazán
Új hozzászólás Aktív témák
-
dabadab
titán
Én a magam részéről a struktúrás függvénypointeres megoldást csinálnám (csináltam).
Ami nagyobb C projekteket láttam, ott is ez köszönt vissza, kicsit úgy nézetek ki, mintha egy régi g++ kimenetét láttam volna, ami még a C++ kódból C-t generált és a függvények első paramétere tulajdonképpen a this volt. -
-
dabadab
titán
válasz
pmonitor
#6242
üzenetére
Bocs, de tényleg nem merül fel benned az, hogy ha nulla tapasztalattal akarsz valamit megmagyarázni olyannak, aki nagyon régóta ezzel foglalkozik, hogy esetleg nem neked van igazad és érdemes lenne legalább megfontolni, amit mond?
És nem, baromira nem szubjektív. Addig érezheted mindegynek, hogy mi hova kerül, amíg nem látod át, hogy azok mit jelentenek. Onnan kezdve viszont nagyon is objektíven értékelhető lesz a dolog.
A 6179-nél például azt nem érted, hogy a vezérlési szerkezet a program lefolyásáról is beszél, márpedig ott mást mond, mint ami a tényleges helyzet.
-
dabadab
titán
válasz
#90088192
#6224
üzenetére
A számítástudomány az tényleg sokkal előrébb járt, mint maguk a számítógépek, George Boole (a Boole-algebra (a számítógépeknél alkalmazott logika) megalkotója halála után még majdnem egy évszázadott kellett várni az első digitális számítógépre, az információelméletről meg Shannon kb. mindent elmondott az 1940-es években.
A GOTO-problematika viszont nem ide tartozik, az színtisztán gyakorlati kérdés - azt Ada Lovelace nem láthatta előre, amikor Babbage gépére talált ki pár soros programokat, hogy milyen érzés lesz olyan kódot túrni, amit egy tíz évvel ezelőtt más céghez távozott kolléga írt
Az, hogy feltétlenül kell egy olyan utasítás, ami megváltoztatja a program végrehajtási helyét, az soha nem is volt kérdés, persze, hogy kell. Sőt, több is kell, mert olyanok is kellenek, amik különféle feltételek alapján változtatják meg.
Az összes processzorban vannak ilyen utasítások, senkinek semmi baja nincs ezzel, senki nem akarja kiírtani, vagyis tulajdonképpen bármilyen program fut a gépeden az tele van JMP-kkel (a GOTO gépi kódú megfelelőjének ez a mnemonikja).
Viszont a magasabb szintű nyelvekbe ezt egyre inkább becsomagolták, mint ahogy minden egyéb ilyen nyers dolgot is, hiszen a programozók általában nem arra vágynak, hogy megváltoztassák a programszámláló tartalmát, mert csak, hanem valamilyen összetett struktúrát hoznak létre: hurkot, feltételes programvégrehajtást, ilyeneket. Márpedig ha ők ilyeneket akarnak létrehozni, akkor adjunk a kezükbe olyan eszközöket, amikkel ezt csinálják közvetlenül, ahelyett, hogy JMP-vel bohóckodnának.
Ezzel együtt a GOTO megmaradt egy csomó magasabb szintű nyelvben is, egyszerűen azért, mert az azokban meglévő struktúrák lefedték a GOTO-használat nagyon-nagyon-nagy részét, de nem az összeset, így aztán maradtak olyan helyek, amikor az ember azt használja, mert adott esetben nincs jobb megoldás rá.
-
dabadab
titán
válasz
pmonitor
#6239
üzenetére
Már megint nem érted.
Senkit nem érdekel az, hogy hány goto van a programban, az az érdekes, hogy mennyire olvasható.
Én a 20+ éves pályám nagy részében olyan, sokmillió kódsoros rendszereken dolgoztam, amik másfél-két-két és fél évtized alatt programozók tucatjai írtak és írtak át. Ebből kifolyólag rengeteget olvasom és módosítom mások kódját és ennyi idő után azért eléggé el tudom dönteni, hogy mi az, ami jól olvasható, a programozó szándékát tisztán kommunikálja és könnyű karbantartani, meg mi az, ami nem az.
A fenti megoldásokkal mind az volt a baj, hogy az eredeti gotos megoldásnál a fenti szempontokból nem hogy nem voltak jobbak, de kifejezetten rosszabbak voltak.
-
-
dabadab
titán
válasz
nevemfel
#6179
üzenetére
Ez egészen rettentes, szerintem.
Az eredetinek van egy teljesen normális logikája, hogy sorban megy végig a lépéseken és ha bármelyik nem sikerül, akkor game over. Ez meg gondos átolvasást igényel, hogy az ember rájöjjön, hogy mi is történik itt - mert maga a struktúra azt sugallja, hogy háromféle, nagyjából egyenértékű dologgal próbálkozunk, amiből az egyiknek kellene sikerülnie.
-
dabadab
titán
Ezzel (meg nevemfel megoldásával) elég nyilvánvalóan az a gond, hogy olyan függvényeket is meghívsz, amiket nem kellene (szabadna) és a kód azt mondja, hogy az, hogy h a vcpu nem runnable, az még tök oké, mert attól még csinálhatunk itt dolgokat, noha ennek pont az ellenkezője a helyzet.
-
dabadab
titán
válasz
pmonitor
#6168
üzenetére
Akkor tessék, demonstráld:
static int kvm_vcpu_check_block(struct kvm_vcpu *vcpu)
{
int ret = -EINTR;
int idx = srcu_read_lock(&vcpu->kvm->srcu);
if (kvm_arch_vcpu_runnable(vcpu)) {
kvm_make_request(KVM_REQ_UNHALT, vcpu);
goto out;
}
if (kvm_cpu_has_pending_timer(vcpu))
goto out;
if (signal_pending(current))
goto out;
ret = 0;
out:
srcu_read_unlock(&vcpu->kvm->srcu, idx);
return ret;
} -
dabadab
titán
Valamint ELTE IK C/C++ gyakorlaton instant évismétlés járt a go to és continue használatért, és értettem hogy miért, miután egyszer valaha valami tele go to-zott programot kellett debugolnom, és visszafejtenem. Fenntarthatatlan és karbantarthatatlan lesz a program tőle.
A hülyén használt gototól. Ez pont olyan, mint amikor idióta magyartanárok előveszik a "macska fel van mászva a fára" mondatot, hogy ezzel szemléltessék, hogy magyarban miért nem szabad szenvedő szerkezetet használni - csak hát valójában a magyarban a szenvedő szerkezet teljesen rendben van, a macskás példával az a gond, hogy pont azt semmilyen nyelven sem mondják szenvedőben, mert az úgy hülyeség (angolul se mondaná senki, hogy "the cat is on the tree climbed").
A jól használt goto a C-ben az a jól olvasható kódhoz sok esetben gyakorlatilag elkerülhetetlen. Tipikus példája az, amikor egy függvény több helyen érhet véget, de mindenképpen fel kell szabadítani resource-oket. Ezt mondjuk C++-ban tök faszán lehet csinálni RAII-vel meg finallyvel C#-ban, de azok tök más nyelvek. C-ben nincs ilyen, ott vagy minden helyre külön odakopipészteled a felszabadítást, vagy mindenhonnan a végére gotozol. Egyértelmű, hogy az utóbbi megoldás az, ami olvashatóbb és ami kevesebb hibalehetőséggel jár.
A C az gyakorlatilag hordozható assembler, ennek megfelelően kell hozzáállni, aki ott azt mondaná, hogy a JMP használatát el kell kerülni, azt kiröhögnék.
-
dabadab
titán
válasz
kovisoft
#6091
üzenetére
amúgy sem jó, mert a feltételben a szimpla = jel nem egyenlőségvizsgálat, ami a dupla ==, hanem értékadás
És az még mindig nem lenne jó, mert a szükségesnek pont a fordítottja lenne - ugyanis az ott nem a kilépés feltétele, hanem az ismétlésés (vagyis akkor hagyja abba a do ... while-t, amikor az NEM igaz)
-
#6062
dabadab
titán
borisz1994
#6061
dabadab
titán
válasz
borisz1994
#6061
üzenetére
Igen, az deklaráció és alapvetően nem kell.
-
#6059
dabadab
titán
borisz1994
#6057
dabadab
titán
válasz
borisz1994
#6057
üzenetére
Benkő Tiborné - Benkő László - Tóth Bertalan : Programozzunk C nyelven! könyvet
Jézusmária
Inkább keress egy jó, érthető könyvet. Szerintem a klasszikus Kernighan-Ritchie "A C programozási nyelv" az elég jó (még ha az apád is lehetne
), én annak idején abból tanultam.Egyébként alapvetően megéretetted: a definíció az egy valaminek (változónak, függvénynek) a pontos leírása és ennek hatására a fordító meg is csinálja az ahhoz tartozó dolgokat (memóriát foglal a változónak, lefordítja a függvény kódját).
A deklaráció meg elmondja a fordítónak, hogy van itt ez az izé és ez tulajdonképpen ilyen típusú, de valahol máshol van leírva.Hogy mire jó?
Azt talán már tudod, hogy a C erősen típusos nyelv, vagyis a fordító mindig megnézi, hogy az a függvény vagy változó, amire hivatkozol, milyen típusú, mennyi és milyen típusú paramétere van - ha pedig olyasmire hivatkozol, amiről még nem hallott, akkor hibát dob.
Amíg az egész programod egy file-ban van, ez általában nem jelent áthidalhatatlan problémát, olyan sorrendbe rakod a definícókat, hogy ha B hivatkozik A-ra, akkor A előbb legyen a file-ban, mint B. De már itt is lehet komplikáció, hiszen mi van, ha az A függvény hívja a B-t a B meg az A-t? Ilyenkor jön jól a deklaráció, hogy az ember leírja a fordítónak, hogy "majd találsz egy B függvényt, ami így fog kinézni, hogy". Ettől a fordító megnyugszik és szépen lefordítja a dolgokat, ha az ellenőrzéseken amúgy átmegy (és majd a linker lesz az, aki kétségbeesik, ha a B definíciója nincs sehol
) -
dabadab
titán
válasz
llaszlo
#5720
üzenetére
"Még mindig ott tartok, hogy az ékezetes karaktereket két helyen tárolja a tömbben."
Mert UTF-8, ott meg csak az első 128 karakter fér el egy byte-ban.
Ha rendesen akarsz ASCII-n túli karakterekkel dolgozni, akkor nézd meg a wchar-t, de ott meg a tömb inicializálása lesz némileg munkás, mert ott kénytelen leszel a konkrét számértékeket bepötyögni, vagy kódból inicializálni.
-
dabadab
titán
"utolsó sor után nincs új sor, ahogy kéri is a feladatban"
Nem, nem ezt kéri. Azt kéri, hogy azután ne legyen üres sor. A \n-nek attól még ott kellene lennie az utolsó sor végén is.
Egyébként valami rettenetesen béna compare toolt használhatsz, mert egy sima diff ezt mondja:
$ diff ref.txt out.txt
13c13
< ****
---
> ****
\ No newline at end of fileEnnyi.
Ha megnézed őket mondjuk egy hexa editorral, hogy láss minden byte-ot, akkor is látszik, hogy összesen ennyi különbség van.
Sőt, ha megnézem a forráskódodat, akkor is látszik, hogy ez a gond
-
dabadab
titán
válasz
alapz@j
#5622
üzenetére
Ha már optimalizálunk, akkor csináljuk rendesen:
switch(c)
{
case 'a':
case 'e:
case 'i':
case 'o':
case 'u':
case 'A':
case 'E:
case 'I':
case 'O':
case 'U':
return 1;
default:
return 0;
}vagy ha van valakinek türelme egy 256 elemű tömböt teleírni egyesekkel meg nullákkal:
return maganhangzok[ c ];
-
dabadab
titán
-
dabadab
titán
válasz
aviator
#5584
üzenetére
"Azért lett pointer a tömb típusa mert később a koordináták címeire lesz szükség."
Ez a hiba. Ha szükség van a koordináták címeire, akkor veszed a címüket a & operátorral
Azzal, hogy az a tömb koordinata* típusú, azt mondtad, hogy ez egy pointert tartalmaz egy koordinata structra - és ez ezt is jelenti. Amikor létrehozod a haromszoget, akkor az létrejön, lesz benne három pointer, amik nem mutatnak sehova (pontosabba valami tök véletlenszerű helyre mutatnak), persze, hogy úgy elszáll a program.
Kénytelen leszel feltölteni ezeket a pointereket kézzel, pl. úgy, hogy foglalsz három koordinata structot, aztán azoknak a pointereit berakod (és amikor nem kellenek, akkor majd nyomsz rájuk egy free-t is). Ez remek dolog, ha valamiért te szeretnéd foglalni ezeket vagy más helyen lefoglalt structok pointerét akarnád felhasználni, viszont úgy tűnik, hogy egyáltalán nem ezt akarod, hanem azt, hogy a fordító hozzon létre neked három koordinata structot, meg aztán majd szabadítsa is fel a megfelelő időben.Szóval ez kell neked:
typedef struct haromszog
{
koordinata csucsok[3];
}haromszog;
haromszog triangle;
scanf("%d %d %d", &(triangle->csucsok[0].x),&(triangle->csucsok[0].y),&(triangle->csucsok[0].z)); -
-
dabadab
titán
És ha már itt pointerezünk, akkor érdemes megemlíteni, hogy vannak dolgok, amiknek nincs címe, pl. általában literáloknak (a stringek kivételek) vagy függvények visszatérési értékének vagy műveletek eredményének:
double x;
double *p;
double **pp;
x=1.0;
p=&x; // OK
pp=&p; // OK
pp=&(&x); // error
p=&1.0; // error
p=&sin(x); // error -
dabadab
titán
"Adott egy stringet módosító függvény, elég egyszerű:"
...és hibás
Az "old = new" rész egyáltalá nem azt csinálja, amit te szeretnél, azok csak a stringedit két lokális változóját módosítják, nem a paraméternek megadottakat.Ezenkívül az elég rossz gyakorlat, hogy hagysz nem feltűnően érvénytelen pointerek, márpedig amikor lefut ez a függvény, utána nem fogod tudni azt, hogy a new az érvényes-e, ezért ilyen esetekben nagyon praktikus lenullázni (plusz ez segít abban, hogy gyorsabban kibukjon az, ha ezután valahol mégis használni akarnád, annak ellenére, hogy érvénytelen).
Ja, és én a magam részéről a "new" használtatát kerülném még C kódban is.
-
-
dabadab
titán
Nyolc bites mikroprocesszoron a C# egyreszt nem letezik, masreszt technikailag kb. lehetetlen megvalositani, harmadreszt meg ha megis sikerul, akkor se akarna senki se hasznalni. (oke, mondjuk a C++ se hangzik tul hihetoen, sot, igazan a C is eleg hatareset)
"Nekem a C, C++ és a C# egy kalap alatt van."
Pedig azert eleg messze vannak egymastol: a C gyakorlatilag hordozhato Assembler a hatvanas evek vegerol, a C# meg nagyjabol minden modern paradigmat (objektumorientacio, generikus programozas, funkcionalis programozas, mittomen) tamogato, virtualis gepen futo cucc.
-
dabadab
titán
válasz
#36268800
#5285
üzenetére
Isten hozott a lebegőpontos számok világában!
Alapvetően két csúnya dolog van velük:
1. a pontosságuk korlátozott, vagyis előbb-utóbb lesznek kerekítési hibák
2. nem tizes, hanem kettes számrendszert használnak, így a tizes számrendszerben kevés tizedesjegyből álló számok simán lehetnek végtelen tizedestörtekHa kiíratnád a MAXP*0.57 értékét, akkor valószínűleg valami olyasmit látnál, hogy 0,57000001. Emiatt lebegőpontos számoknál számolni kell azzal, hogy az egyenlőség nem fog működni és nem egzakt egyenlőséget vizsgálni, hanem azt, hogy az adott szám benne van-e valamilyen tartományban.
-
dabadab
titán
válasz
EQMontoya
#5258
üzenetére
"Goto-t igazából a C korszakban igyekeztek nagyon írtani"
Valójában Dijkstra ismert cikke '68-as, a C-n meg '69-ben kezdtek el dolgozni Ritchie-ék, szóval a goto utálata megelőzi a C-t és igazából az a fajta vallásos utálat, ami bizonyos körökben megvolt a gotoval kapcsolatban, nem igazán volt indokolt.
-
dabadab
titán
"APL(-szeru) nyelven neztem bazi hosszu, teljesen strukturalatlan kodokat - ott ugye nem jellemzoek a fuggvenyek, viszont az sem, hogy regesreg krealt ertekeket hasznalsz sokkal-sokkal kesobb; inkabb sok-sok egymas utan kovetkezo es egymasra epulo lepest irnak le."
Azert ott is joval olvashatobb es kovethetobb lesz a kod, ha ugy nez ki, hogy van egy fuggvenyed, hogy
do_something_complex()
{
do_something_simple();
do_something_even_simpler();
// ...
}es az egyes lepeseket kirakod sajat fuggvenybe. A fordito meg ugyis inline-olja a fuggvenyeket, szoval meg csak lassabb se lesz.
-
dabadab
titán
"Tehat vegulis az ok, amiert szet akarod szedni, az a konnyebb navigacio."
Nem csak a navigacio, hanem a fuggveny atlathatosaga is: ugyanis ilyen szerkezetnel siman elofordul, hogy olyan valtozokra hivatkoznak, aminek par szaz sorral korabban adtak valami erteket. (Ami IDE-kkel eddig talalkoztam, azok csak a komplett switchet tudtak osszehajtogatni, az egyes case agakat nem)
Bocs, de most tenyleg nagyon latszik, hogy soha az eletben nem kellett ilyenekkel szenvedned, azert nem gondolod ezt problemasnak
-
dabadab
titán
"bar sokan azt valljak, hogy egy fuggveny ne legyen hosszabb X sornal, de ez szerintem butasag"
Ezt csak azert mondod, mert meg nem kellett olyan fuggvenyeket kibogoznod, amikor tobb ezer sor hosszuak voltak, bennuk tobbszorosen egymasba agyazott switchekkel, ami azt eredmenyezi, hogy a "hol vagyok a kodban?" kerdesre a valaszt tobb perces scrollozgatas adja meg.
Igazabol ha egy fuggveny kezd hosszu lenni (mittomen, tobb, mint szaz soros), akkor erdemes eltoprengeni azon, hogy nem lenne-e erdemes megis szetszedni. Erre persze lehet az is a valasz, hogy "nem", de azert toprengeni erdemes.
-
dabadab
titán
válasz
#36268800
#5230
üzenetére
"A kérdésem az volna ezzel kapcsolatban, hogy mi a különbség az egyszerű "if" és az "else-if" között?"
Az, hogy sima if-eknél (megfelelő feltételek esetén) a program akár az összes if-be belemehet, if-else-eknél viszont legfeljebb csak egybe. Neked itt pont az else-if kell, mert egymást kölcsönösen kizáró feltételeid vannak.
"Esetleg valamelyik gyorsabban lefut?"
Ez is benne van, ha if-else-eknél belemegy valamelyik ágba, akkor utána a komplett blokk végére ugrik, nem nézi meg a többi feltételt. Mondjuk ez olyan különbség, ami tipikusan olyan kicsi, hogy mérések sem mutatják ki.
"A Microsoft Visual Studio-t használom, hol találom benne a program gyorsaságát?"
VS 2013-ban van profiler, de őszintén szólva nem hiszem, hogy jelenleg neked erre bármi szükséged lenne. Az ekkora programok futási ideje bőven mérési hibán belül van.
"Mi a véleményetek a kódom tagoltságáról?"
Így azért jóval olvashatóbb (ez az else-if szokásos írásmódja):
int main(void)
{
float num1, num2;
printf("Enter two numbers\nFirst: "); scanf("%f", &num1);
printf("Second: "); scanf("%f", &num2);
if (num1 == num2)
{
printf("They are equal: %f = %f", num1, num2);
}
else if (num1 > num2)
{
printf("They are not equal, %f > %f", num1, num2);
}
else
{
printf("They are not equal, %f < %f", num1, num2);
}
getch();
return 0;
}Ezen túlmenően ekkora kódnál azért különösebb tagoltságról nem lehet beszélni
ÁLtalános megjegyzésként még annyi, hogy lebegőpontos számoknál a == csak nagyon korlátozottan használható (itt mondjuk pont igen), mert ott a kerekítési hibák miatt előfordulhat, hogy két érték, aminek elméletben azonosnak kellene lennie, mégsem lesz pont ugyanannyi.
-
dabadab
titán
-
dabadab
titán
Igazából a ravaszság az, hogy nem is kell ténylegesen transzponálni a mátrixot.
Gondolom valami kétdimenziós tömböt alkalmaztál a mátrix tárolására, szóval a tomb [A]x,y elemet valahogy úgy kapod meg, hogy elem=matrix[x][y]. Ha a transzponált mátrix [AT]x,y elemére vagy kiváncsi, akkor egyszerűen ki kell olvasni az eredeti mátrix [A]y,x elemét, vagyis transposed_element=matrix[y][x];
Röviden: olvasáskor egyszerűen cseréld fel az x-et meg az y-t és máris megvan a transzponált mátrix -
dabadab
titán
válasz
EQMontoya
#5176
üzenetére
Valami beágyazott rendszerről van szó, ami a PC-kkel ellentétben az OS-t meg a programokat meg egyebeket nem bootkor olvassa be a RAM-ba valami háttértárról, hanem egyrészt valószínűleg OS egyáltalán nincs, ami program meg fut, az fixen flash memóriában van, nem RAM-ban (ezekben a cuccokban egyébként tipikusasn több a flash, mint a RAM, tehát ha valamit át lehet rakni RAM-ból flashbe, az áltlában jó dolog), márpedig egy const tömb az a program része.
-
dabadab
titán
-
-
-
dabadab
titán
"Adott egy M mátrix a nagyságát én adom meg, az elemeit pedig random töltöm fel... eddig el is jutottam"
Igazából nem. Lefoglalsz egy fix nagyságú mátrixot, aztán ha valaki egy nagyobbat ad meg, akkor simán felülírsz mindenféle memóriaterületet. malloc()-ról még nem volt szó?
"a páratlan elemeit ki kéne íratnom egy külön sorba..."
És ezen hol akadtál el? Nem tudtad eldönteni, hogy melyik páratlan?
szerk: ahogy látom, mások már mind megírták ezt
-
dabadab
titán
válasz
buherton
#4765
üzenetére
Szerintem Karmanak nem a driverekkel van problemaja, hanem azzal, hogy teljesen random* helyekre ellenallasokat, kondenzatorokat meg egyeb bigyokat kell kotni es ezeket mindenki olyan termeszetesnek veszi, mint a levegovetelt (es ennek megfeleloen nem is nagyon emlitik a szuksegesseguket)
*: nyilvan nem, meg en is szigorlatoztam elektronikabol, de ha barmikor szentte akarnak avatni, akkor azt a harmast nyugodtan felsorolhatjak a csodateteleim kozott
-
dabadab
titán
válasz
alapz@j
#4750
üzenetére
Az a pont, ahol egy kifejezes teljesen ki van ertekelve, a Wikipediaban van konkret lista illetve a C FAQ-ban egy reszletesebb magyarazat.
-
dabadab
titán
-
dabadab
titán
válasz
tototos
#4687
üzenetére
sec += 2;
sec %= 60;Mondjuk a "while(act_sec<wait)" az problemas lesz tulcsordulaskor.
De mondjuk olyan fuggveny nincs, ami eleve masodpercben (msec-ben, usec-ben) adja vissza az idot?
(#4685) don_peter: "PHP-és vagyok, de ott sokkal egyszerűbbek voltak a dolgok."
Egyszerubbek semmikeppen nem voltak, csak valoszinuleg nem csinaltal semmi olyat, ahol kellett volna tudnod, hogy a konkret bitek szintjen mi is tortenik.
-
dabadab
titán
válasz
don_peter
#4668
üzenetére
En ilyenkor mindenkeppen kulon kezelnem az adatokat (a menustrukturat) meg annak a kezeleset - az elobbit adatstrukturakban tarolnam es a kod csak azokat a strukturakat manipulalna - ahelyett, hogy beleirnam a programkodba a menupontokat (mert ha jol veszem ki a szavaidbol, akkor pont ezt csinalod). Ugyanis igy egyreszt joval kisebb es atlathatobb kod lesz, atlathatobbak lesznek az adatok is es a modositas is joval egyszerubb lesz.
-
dabadab
titán
válasz
don_peter
#4663
üzenetére
A goto pár helyen teljesen normális megoldás C-ben, pl. akkor, ha több, egymásba ágyazott ciklusból akarsz kiszállni vagy ha a függvényből több helyen is ki lehet szállni, viszont mindenhol meg kell csinálni ugyanazt (file-t lezárni, memóriát felszabadítani, ilyesmi).
Arra viszont, amire te akarod használni, határozottan ellenjavallt.
Az nem derült ki pontosan, hogy mi kell neked, de az egészen biztos, hogy sokkal jobb megoldások vannak rá, mint a goto. -
dabadab
titán
válasz
don_peter
#4645
üzenetére
"Amikor ki akarok írni memóriába egy 16bites adatot akkor ott (short int) hogy tudom kiírni amikor maximum 1bájtonként tud írni a buffer regiszterbe?"
(Gondolom ez a buffer regiszter vmi i/o port)
Ertelemszeruen byte-onkent
typedef unsigned short u16;
void u16_to_port(u16 input)
{
buffer_reg = u16 & 0xff;
// write buffer
buffer_reg = u16 >> 8;
// write buffer
} -
dabadab
titán
válasz
don_peter
#4615
üzenetére
Ez az elso printf-nel el fog szallni, mert nincs lezarva nullaval, aztan utana az strlen-nel ugyanazert
Ha csak egy stringet akarsz torolni, akkor
ttomb[0] = 0;Ha meg az egesz tombot torolni akarod, akkor meg
memset(ttomb, 0, sizeof(ttomb));(A '\0' erosen tul van cicomazva szerintem
) -
dabadab
titán
válasz
don_peter
#4577
üzenetére
Ja, igen, get_key() helyett konzekvensen getchar()-t irtam, felig mar autopiloton volt az agyam
""PORT_B4" egyenlő a következővel : PORTBbits.RB4"
Ja, akkor az egy bitfield lesz, azon meg meg sokkal egyszerubb vegigmenni, tomb se kell hozza:
#define SOROK_SZAMA 4
#define NO_KEY 0
#define FIRST_ROW_BIT_POSITION 4
#define FIRST_COL_BIT_POSITION 4
#define NO_OF_COLS 4
int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };
unsigned char get_key()
{
unsigned int i, k=0;
for( i=0; i < SOROK_SZAMA ; i++ )
{
SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) ); //Léptetjük a sorok szintjét
for ( j = FIRST_COL_BIT_POSITION ; j < FIRST_COL_BIT_POSITION + NO_OF_COLS ; j++ )
{
k++;
if( PORTBbits & (1 << j) )
{
while( PORTBbits & (1 << j) ); //Várakozunk a gomb felengedéséig
return k;
}
}
}
return NO_KEY;
}"Ha igen akkor ő nem a bit állással kell vissza jöjjön hanem a beolvasott karakterrel ami 1,2,3...16-ig."
Igen, pont ezert mondtam, hogy ott nem jo az, hogy azt adod vissza, hogy ALACSONY, mert az nem karakter
"Ez egy végtelen ciklus nem?"
De, ez az, errol irtam, hogy ez nem szamit, mert a k-t ezen belul inicializaljuk.
), én annak idején abból tanultam.
![;]](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!
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- BESZÁMÍTÁS! MSI X470 R7 5800X 32GB DDR4 512GB SSD ROG STRIX RTX 2080 Super 8GB Rampage SHIVA 650W
- BESZÁMÍTÁS! ASUS H81M-PLUS H81 chipset alaplap garanciával hibátlan működéssel
- Lenovo ThinkPad X270 (16) - i5-7300U, 16GB, 512GB SSD, 12" FULL HD
- 13-14" Új és használt laptopok , üzletitől a gamerig , kedvező áron. Garanciával !
- Microsoft Surface Book 3 - 15 col
Állásajánlatok
Cég: Promenade Publishing House Kft.
Város: Budapest
Cég: CAMERA-PRO Hungary Kft
Város: Budapest