Új hozzászólás Aktív témák

• #5684 dobragab addikt maestro87 #5683

  Új Válasz 2016-06-11 18:39:36 #5684

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  dobragab

  addikt

  válasz maestro87 #5683 üzenetére

  "Összetett literális".

  Alaptípusokra, mint amilyen az int, az unsigned long, a double, tudsz a programkódba beágyazott konstansokat írni. Pl: 0, 25UL, 0x0badc0de, 4.6f, 0.001. Speciális literal még a string literal, amit így ismersz: "Hello world!\n".

  Struktúrákra, union-okra, tömbökre C89-ben ilyet csak inicializálásnál tudsz:

  struct Pont p = {5, 12};
int arr[] = {1, 2, 3, 5, 8, 13, 21};

p = {12; -5}; // <- ERROR
p.x = 12;
p.y = -5; // <- macerás

  C99 behoz ezzel kapcsolatban két feature-t, a compound literal és a designated initializer.

  Compound literal

  Arra való, hogy a programkódban ne csak ilyen alaptípusokat, hanem összetett típusokat is meg lehessen adni egyetlen kifejezésben. Ehhez ugyanaz a szintaxis, mint az inicializálásnál, konyhanyelven annyi különbséggel, hogy a kapcsos zárójel tartalmát az adott típusra kell "cast-olni".

  p = (struct Pont){12; -5};

struct Pont Pont_tukroz(struct Pont p)
{
return (struct Pont){p.y, -p.x};
}

struct Pont q = Pont_tukroz((struct Pont){10, 13});

  printf("%p\n", (int[]){1});

double osszeg = double_osszeg((double[]){1.0, 2.718, M_PI}, 3);

  Ezek a "változók" temporális objektumok, nincs nevük, nem képezheted a címét, mint ahogy ez is értelmetlen:

  printf("%p", &1);

  Élettartamuk a blokk végéig tart (bezáró }), nem úgy, mint C++-ban, ahol a pontosvesszőig (jó, nem pont így van a szabványban, de megközelítőleg pontos).

  Designated initializer

  C-ben a struktúrák adattagjait közvetlenül érjük el, szinte mindig név szerint.

  void Pont_kiir(struct Pont p)
{
printf("(%d, %d)", p.x, p.y);
}

  Kivéve: inicializálásnál.

  struct Pont p = {5, 12};

  Ez egyértelműnek tűnik, az x koordináta 5 lesz, az y pedig 12. De mi történik, ha valami bunkó így definiálta a struct Pont-ot?

  struct Pont
{
int y;
int x;
}

  Ilyenkor minden működik tovább, kivéve az inicializálást, akkor pont fordítva történnek a dolgok, mint ahogy az ember elképzelte. Ezért vezették be, hogy a struktúrákat inicializálni is lehessen név szerint:

  struct Pont p = {.x = 5, .y = 12};

  Természetesen compound literal-lal együtt is használható.

  p = {.x = 5, .y = 12};

  És nem csak struktúrákra, tömbökre is.

  int arr[] = {[0] = 8, [1] = 13, [2] = 21};

  Sőt, vegyesen is.

  haromszog_rajzol((struct Pont[])
{
[0] = {.x = 12, .y = 5},
[1] = {.x = -12, .y = 5},
[2] = {.x = 0, .y = 0}
});

  Jó eséllyel ezeket a te fordítód is támogatja, ha GCC vagy Clang, csak -std=c99 kell neki. MSVC a C99 cuccokat a 2015-ös verzió óta zömmel tudja...

  EQMontoya: bocsi a magyar változónevek miatt

• #5677 dobragab addikt maestro87 #5676

  Új Válasz 2016-06-10 15:42:53 #5677

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  dobragab

  addikt

  válasz maestro87 #5676 üzenetére

  C-ben is lehet OO kódot írni, csak nehezebb, öröklést csinálni pedig undorító. Az OOP elveket viszont explicite nem támogatja a C, azaz egy C-s "osztályt" bármikor lehet szarul használni, C++-ban többé-kevésbé a használójára rá lehet kényszeríteni a "jó" használatot. Legalábbis dióhéjban ennyi.

  (#5675) ToMmY_hun

  C++-ban szerintem gátlástalanul lehet return-ölni akárhonnan. C-ben vigyázni kell, mert lehet, hogy pl. hibajelzésre használt visszatérés előtt fel kéne szabadítani valami erőforrásokat, és nem történik meg automatikusan. Erre (C-s kivételkezelés) majd fogok szülni egy másik hsz-t, még a goto kapcsán.

• #5674 EQMontoya veterán maestro87 #5671

  Új Válasz 2016-06-10 14:58:59 #5674

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  EQMontoya

  veterán

  válasz maestro87 #5671 üzenetére

  Van, amikor nincs ++i.
  Pl, c++.ban:
  for(const auto& i : my_list) { ... }

  A continue-ban azt szeretjük, hogy az minden nyelven ugyanúgy működik.
  És hidd el, azt mindenki érti, ha pedig a ciklus közepén a ciklusváltozóhoz nyúlsz, az:
  -Sokkal kevéssé érthető
  -Jobb helyen arconvágnak érte, mert nagyon veszélyes.

  Pl.
  for(int i = 0; i < valami ; ++i)
{
if(zöld(tömb[i]) && pöttyös(tömb[i])) continue;
if(sarga(tömb[i]) && !csikos(tömb[i])) continue;
//do something here...
}

  Sok sikert ++i-vel.

• #5673 ToMmY_hun senior tag maestro87 #5671

  Új Válasz 2016-06-10 14:58:47 #5673

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  ToMmY_hun

  senior tag

  válasz maestro87 #5671 üzenetére

  Kereső algoritmusokban a keresett elem megtalálásakor hasznos lehet a continue. Olyankor is, amikor előfeltételként vizsgálod a ciklusmagban egy számításigényes művelet elvégzésének szükségességét. (Erre írt példát EQMontoya).

  A mikrokontrollerek programozásához pedig nagyon kevés, speciális esetben van szükség C++ használatra. Komplexebb problémák megoldása során találkozhatsz vele, úgy mint például orvostechnikai berendezések, robotika stb. A "mitől job" kifejezés pedig nem a legcélszerűbb megfogalmazási módja a kérdésnek, nem jobb és nem is rosszabb, szimplán más a létezésének célja.

• #5672 dobragab addikt maestro87 #5671

  Új Válasz 2016-06-10 14:55:06 #5672

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  dobragab

  addikt

  válasz maestro87 #5671 üzenetére

  ++i tök mást csinál. continue igazából arra való, hogy ne legyen annyi egymásba ágyazás. A fenti kód így írható át:

  void print_primes(int * primes, int lenght)
{
for(int i = 0; i < lenght; ++i)
{
if(primes[i]>=2)
{
/* és egy rakás random utasítás */
if(is_prime(primes[i]))
printf("%d\n", primes[i]);
/* meg itt is sok utasítás */
}
}
}

  A bitb*szogatás nem az én területem, de tudomásom szerint a continue asm-ben 1 db jump lesz, ugyanúgy, ahogy az if is.

  C++ C-hez képest nagyon sok mindent tud, amit neked első körben érdemes megnézned, az az objektumorientált tervezés.

• #5667 EQMontoya veterán maestro87 #5665

  Új Válasz 2016-06-10 14:06:24 #5667

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  EQMontoya

  veterán

  válasz maestro87 #5665 üzenetére

  void print_primes(int * primes, int lenght)
{
for(int i = 0; i < lenght; ++i)
{
if(i<2) continue;
if(is_prime(i)) printf("%d\n", i);
}
}

  Így a paraméterként kapott tömb negatív elemeire le sem fut a prímtesztelés, mert ugye nincs is értelme, lehet, hogy felkészítve sincs rá.
  Teccikéteni?

  Hú, de nehezen ment c++ nélkül

• #5666 ToMmY_hun senior tag maestro87 #5665

  Új Válasz 2016-06-10 13:52:20 #5666

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  ToMmY_hun

  senior tag

  válasz maestro87 #5665 üzenetére

  Oké, igazad van. Valóban figyelmetlen voltam Kicsit félrevezető a TutorialsPoint-os kód, szerintem nem túl célszerű így demonstrálni a continue működését.

• #5664 ToMmY_hun senior tag maestro87 #5663

  Új Válasz 2016-06-10 13:25:55 #5664

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  ToMmY_hun

  senior tag

  válasz maestro87 #5663 üzenetére

  "Lehet online futtatni a kódot és ha kitörlöd a continue-t ugyanaz lesz a kimenet."

  Ahogy nézem nem fordítja újra a kódot az "Execute" hatására. Kezdőként inkább saját gépen játszadozz, abból is sok hasznos tapasztalatot lehet gyűjteni.

• #5662 ToMmY_hun senior tag maestro87 #5661

  Új Válasz 2016-06-10 10:57:18 #5662

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  ToMmY_hun

  senior tag

  válasz maestro87 #5661 üzenetére

  Nem ugyanaz, mert a 15-öt nem printeli ki, continue nélkül pedig megtenné. Annyi a lényege, hogy ciklusmagban lévő continue utasítás hatására a ciklustörzsből azonnal visszaugrik a végrehajtás a ciklus fejére.

• #5655 dobragab addikt maestro87 #5654

  Új Válasz 2016-06-08 21:03:19 #5655

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  dobragab

  addikt

  válasz maestro87 #5654 üzenetére

  emp.doj egy három elemű tömb, amit inicializálni csak akkor tudsz, amikor létrehozod az emp változót.

  Employee emp = {
"John Sample", 0, 2500,
{1, 1, 1970},
{1, 1, 1970},
{1, 1, 1970}
};

  Külön inicializálni már nem tudod, csak értéket adhatsz neki. Illetve nem is neki, mert C-ben nincs tömbök közötti értékadás, hanem az elemeinek, mégpedig egy létező dátumot:

  date date0 = {1, 1, 1970};

  Ezután adhatsz értéket az emp.doj elemeinek.

  emp.doj[0] = date0;
emp.doj[1] = date0;
emp.doj[2] = date0;

  Itt segítségedre lehet a C99 compound literal:
  emp.doj[0] = (date){1, 1, 1970};

  Ha kinullázni szeretnéd egy struktúra adattagjait, akkor ez nem szabványos, normális fordító nem eszi meg:
  date date0 = {};

  Ez viszont igen:
  date date0 = {0};

• #5653 buherton őstag maestro87 #5651

  Új Válasz 2016-06-08 20:10:27 #5653

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  buherton

  őstag

  válasz maestro87 #5651 üzenetére

  Így próbáld meg
  mp.doj[]=
{
{,,},
{,,},
{,,}
};

  Valahogy így:
  typedef struct
{
int date;
int month;
int year;
} date;

typedef struct
{
char ename[20];
int ssn;
float salary;
date (*doj)[3];
} Employee;

date foo = ...;

Employee emp;
emp.doj[0] = &foo;

  Nem próbáltam lefordítani.

• #5652 maestro87 őstag maestro87 #5651

  Új Válasz 2016-06-08 20:07:37 #5652

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  maestro87

  őstag

  válasz maestro87 #5651 üzenetére

  Utolsót elírtam. Természetesen immáron emp.doj[]-t írtam nem emp.date[]-t.

• #5650 buherton őstag maestro87 #5649

  Új Válasz 2016-06-08 19:40:38 #5650

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  buherton

  őstag

  válasz maestro87 #5649 üzenetére

  Definiálod a struktúrát, létrehozod a változót és majdan így adsz annak értéket valahogy: emp.date[] = {}; Érdemes memsettel rögötn nullázni is.

  MOD: miért nem pointer a date és akkor a probléma le lenne tudva. Sőt jobb, ha egy láncolt listát csinálsz és kész.

• #5482 dobragab addikt maestro87 #5481

  Új Válasz 2015-12-18 21:56:36 #5482

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  dobragab

  addikt

  válasz maestro87 #5481 üzenetére

  Ha jól értelmezem, a --FLOAT és a --DOUBLE független egymástól. Azaz ha csak --FLOAT=32-t adsz neki, akkor a double ugyanúgy 24 bites marad, ami szerintem nem vicces. Zavaró lehet, hogy a float pontosabb, mint a double, sőt, szemantikailag is rossz.

  Így a float 32 bites értékeket tud tárolni, de számolni csak 24 bittel tud. C szabvány szerint minden lebegőpontos művelet előtt double-re vagy long double-re konvertálódnak az operandusok. Szóval a te esetedben semmit nem ér.

  Ha 32 bites lebegőpontos számítás kell, akkor --DOUBLE=32 mindenképp kell. Az a te döntésed, hogy a float-ot meghagyod-e 24 bitesnek, és ahol kell a pontosság, ott double-t írsz float helyett; vagy teszel az egészre és mindkettőt 32 bitesre állítod. Én az előbbit tenném, figyelembe véve a saját kódolási stílusomat. Mindenhol double-t használok, kivéve ott, ahol a memóriával takarékoskodni kell.

• #5479 dobragab addikt maestro87 #5478

  Új Válasz 2015-12-18 16:32:47 #5479

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  dobragab

  addikt

  válasz maestro87 #5478 üzenetére

  A dokumentáció 105. oldalán a --FLOAT-nál ott van két link a doksi két másik pontjára, hogyan kell az IDE-ben beállítani a parancssori argumentumokat

  Tudomásom szerint minden IDE a parancssoros fordítót hívja meg, az gyakorlatilag aköré épített GUI.

• #5477 dobragab addikt maestro87 #5473

  Új Válasz 2015-12-18 11:57:12 #5477

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  dobragab

  addikt

  válasz maestro87 #5473 üzenetére

  Nem ismerem a fordítód #pragma-kezelését, de szerintem nem így működik. A #pragma fordító-függő, mindegyik azt csinál vele, amit akar, és a számára értelmezhetetlen #pragma-kat ignorálja. Szóval ha ezt nem tudja értelmezni, akkor is lefordul.

  --FLOAT=32

  Én úgy értelmeztem a dokumentációt, hogy ezt a parancssori argumentumok között kéne odaadni a fordítónak.

  cc whatever.c --FLOAT=32

• #5475 jattila48 aktív tag maestro87 #5473

  Új Válasz 2015-12-17 23:14:59 #5475

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  jattila48

  aktív tag

  válasz maestro87 #5473 üzenetére

  A float példádból az látszik, hogy a pontos bináris ábrázolásból az alsó legalább 7, de legfeljebb 12 bitet elhagyja, majd kerekít. Ha csak 6 bitet hagyna el, akkor a kiírásban pontos értéket, míg ha 13 bitet, akkor kisebb értéket (6119424) kaptál volna. Pl. lehet, hogy az alsó 8 bitet hagyja el (valószínűleg így van). Szerintem a float-od 24 bites, amiből a mantissza 16 bit (előjellel együtt, vagyis 15 értékes bit), a karakterisztika pedig 8 bit. Ha 32 bites float-ra is ugyanez a kiírás adódik, akkor a mantissza szintén 16 bit, viszont a karakterisztika is 16 bit (bár ennek nem sok értelme lenne). A float érték úgy ábrázolódik, hogy a mantissza 15 értékes bitjét 0,xxxxxxxxxxxxxxx értéknek tekinted (0, kettedes vessző után jönnek a mantissza bitjei), amit megszorzol 2^karakterisztika-val. 8 bites karakterisztikával kb. 2^127 nagyságrendű számokat tudsz ábrázolni, vagyis bőven elég nagyokat. Viszont 16 bites mantisszával legfeljebb 1/2^16 relatív pontosság érhető el. Az, hogy hány tizedes jegyre (vagy "kettedes" jegyre) pontos az ábrázolás (ez az abszolút hiba), függ a szám nagyságától, ezért csak relatív pontosságról van értelme beszélni (abszolút hiba/pontos érték). A példádban a relatív hiba 64/6123456, ami megfelel a 15-16 bites mantisszának. Ami a szorzást illeti: egész biztos, hogy mindkét operandusod float-ra fog konvertálódni, vagyis 8 bites karakterisztikával bőven ábrázolható lesz, viszont a relatív hiba ugyanúgy megmarad 1/2^16 felső korláttal. Mivel az operandusok már hibával terheltek, ezért a szorzat is az lesz (szorzásnál a relatív hibák összeadódnak). Tehát nem a kiírásnak vannak korlátai (legfeljebb normál alakban írja ki), hanem a szám ábrázolásnak, amit tudomásul kell venni, és így kell velük dolgozni. Természetesen ezekkel a korlátokkal is megvalósíthatsz tetszőleges pontosságú egész vagy float aritmetikát, azonban ez igen macerás.

• #5472 zka67 őstag maestro87 #5471

  Új Válasz 2015-12-14 12:04:47 #5472

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  zka67

  őstag

  válasz maestro87 #5471 üzenetére

  Szia, a fordítód alapértelmezett beállítása 24 bites lebegőpontos számok. Így ne csodálkozz, ha csak az első néhány számjegye pontos. A --FLOAT=32 opcióval állítsd át 32 bitesre a lebegőpontos számok formátumát, és így már 6 tizedesig pontos lesz. Továbbá a doksid 143. oldalán megtalálod a különböző változó típusok pontosságát, így nem igaz, hogy csak 16 bites számokat tud kezelni a fordítód. Van pl. signed és unsigned short long, és signed és unsigned long, 24 és 32 bites méretben.

  A lebegőpontos számoknál pontosabb eredményt kapsz, ha tudod hogy hány tizedesjegy pontosságra van szükséged, és egész számokat használsz. Ha pl. 3 tizedes elég, akkor megszorzod pl. at 123.456-ot 1000-el és 123456-al dolgozol, amikor pedig az eredményre van szükséged akkor osztod 1000-el és meg is van a számod egész része. És gyorsabb is.

• #5470 zka67 őstag maestro87 #5468

  Új Válasz 2015-12-13 13:21:24 #5470

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  zka67

  őstag

  válasz maestro87 #5468 üzenetére

  Szia, vagy használhatod a %f-et is, így:

  int main(int argc, char* argv[])
  {
  uint16_t a = 65535;
  float b = 100.0;
  
  printf("a*b=%8.0f\r\n", a*b);
  
  return 0;
  }

• #5469 dobragab addikt maestro87 #5468

  Új Válasz 2015-12-13 13:18:47 #5469

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  dobragab

  addikt

  válasz maestro87 #5468 üzenetére

  Vigyázz a formátumsztringgel. A formátumnak egyeznie kell a paraméterként kapott típussal. pl. ha ezt akarod kiíratni:

  10 * 10.5

  akkor ahhoz %f kell, mert a kifejezés double típusú.

  Ha ugyanezt szeretnéd integer-ként (%d) kiíratni, akkor a típust hozzá kell igazítani a formátumsztringhez.

  printf("%d", (int)(10 * 10.5));

• #5448 buherton őstag maestro87 #5447

  Új Válasz 2015-11-21 17:49:45 #5448

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  buherton

  őstag

  válasz maestro87 #5447 üzenetére

  Írásra törlődő regiszterek esetén határozottan célszerű a maszkolás, vagy ha nem direktben egy címre írsz, hanem mondjuk egy struktúra pointer által mutatt pointerre, ahol már nincs castolás, és kapásból memória korrupció léphet fel. Ez kvázi egy ököl szabály, hogy csak azokat a biteket engedjük át, ami valós értéket képviselnek. A többi maszkoljuk.

  Közben eszembe jutott még egy példa. Mi van ha a változó értéke éppenséggel -1? Az egész változó tele van 1-esekkel.

  MOD: ilyenekre nincs iromány.

• #5446 zka67 őstag maestro87 #5443

  Új Válasz 2015-11-20 22:53:10 #5446

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  zka67

  őstag

  válasz maestro87 #5443 üzenetére

  A Keil ARM C fordítója pl. figyelmen kívül hagyja az 0xFF-el történő maszkolást, ha 8 bites a cél operandus, azaz nem tesz bele feleslegesen még egy utasítást a lefordított kódba. De én is mindig beleírom a forráskódba, mert így értelmezhetőbb a program.

• #5445 buherton őstag maestro87 #5443

  Új Válasz 2015-11-20 22:12:02 #5445

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  buherton

  őstag

  válasz maestro87 #5443 üzenetére

  Hülyeség ellen védenek a maszkolással. Érdemes rászokni, mert sok bosszságtól kímél meg.

• #5444 kispx addikt maestro87 #5443

  Új Válasz 2015-11-20 22:06:51 #5444

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  kispx

  addikt

  válasz maestro87 #5443 üzenetére

  A 0x0ff-vel való 'és'-elés kell, mert ez távolítja el a 10 bites cím első két bitjét.
  0x03-mal való 'és'-elésre miértjére egyelőre nem tudok választ adni. Akkor látnám értelmét, hogy ha a 11. 12. ... biteket is ki szeretné nullázni.

• #5442 Karma félisten maestro87 #5441

  Új Válasz 2015-11-20 20:08:58 #5442

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  Karma

  félisten

  válasz maestro87 #5441 üzenetére

  1) Nekem is feeslegesnek tűnik, mintha nem akartak volna üres zárójeleket írni.

  2) A vessző egy alap C operátor, azt jelenti, hogy sorban végrehajtja a három műveletet, és az utolsónak az eredményét adja vissza. Az első két tag elég fontos, ezzel címezi meg az EEPROM adott celláját és engedélyezi az olvasást – ezek nélkül a harmadik tagnak semmi értelme.

Új hozzászólás Aktív témák