Új hozzászólás Aktív témák
-
Jester01
veterán
válasz
Szittja
#4121
üzenetére
Szittja: a kill függvénnyel vagy az azonos nevű közismert segédprogrammal.
krisztianAMG: azért mert a scanf_s csak úgy szereti a string beolvasást ha a hosszt is megadod, pl. így: scanf_s("%s", 99, string); Ezt egyébként az msdn szépen le is írja, tessék máskor ott olvasgatni.
Bobrooney: javaslom nézz utána a scanf-nek és a pointer-tömb ekvivalenciának.
-
#4116
Jester01
veterán
lockdown90
#4115
Jester01
veterán
válasz
lockdown90
#4115
üzenetére
Ha csak a kiíráshoz kell, akkor a printf formátumok megfelelő használatával ez megoldható:
printf("%.*s_%d\n",strlen(tomb[i].nev)-2,tomb[i].nev,i+1);
(persze ellenőrizni kellene, hogy a név legalább 2 karakter-e). -
#4114
Jester01
veterán
lockdown90
#4113
Jester01
veterán
válasz
lockdown90
#4113
üzenetére
Ezt a kérdést nem igazán értem, mit akarsz átírni?
Általánosságban: lekéred a string hosszát és szépen index alapján felülirod kézzel vagy strncpy-vel. -
#4112
Jester01
veterán
lockdown90
#4110
Jester01
veterán
válasz
lockdown90
#4110
üzenetére
A javított verzió nekem működik.
-
Jester01
veterán
válasz
hoffman_
#4100
üzenetére
A maszkolás az bináris dolog, akkor jó ha bitekkel dolgozol. Jelen esetben az alsó két bitet kell leválasztani erre az & 3 az pont jó is, vizsgálni viszont az 10 kombinációt kell aminek az értéke 2.
A helyiértékes dolog ennek a tízes megfelelője és arra az osztás művelet jó. Ugye az egyesek száma az simán 10-el vett maradék, tehát x % 10. A tízesek száma ugyanez csak még egy tízzel való osztás is van benne: (x / 10) % 10. A százas helyiértéknél már 100-al kell osztani és így tovább.
-
-
Jester01
veterán
válasz
buherton
#4091
üzenetére
A grep kimenet alapján az ex_init4.c-ben van benne tehát a "jogos tulajdonos" ő. Ha a linker szerint az ex_task4.o-ban is benne van, az azt jelenti, hogy huncutság van, például az ex_task4.c-ben lehet egy #include "ex_init4.c". Mindenesetre valahogy belekerül abba a modulba is, azt kell kinyomozni, hogyan.
-
#4088
Jester01
veterán
hunterrop8
#4087
Jester01
veterán
válasz
hunterrop8
#4087
üzenetére
Ha egy függvényből két értéket akarsz visszaadni akkor használj struktúra típusú visszatérési értéket vagy pointereket.
struct result {
int vowels;
int consonants;
};
struct result count(const char* text) { ... }
int main() {
struct result r = count("...");
printf("%d %d\n", r.vowels, r.consonants);
return 0;
}-vagy-
void count(const char* text, int* vowels, int* consonants) { ... }
int main() {
int vowels, consonants;
count("...", &vowels, &consonants);
printf("%d %d\n", vowels, consonants);
return 0;
} -
#4078
Jester01
veterán
stranger28
#4077
Jester01
veterán
válasz
stranger28
#4077
üzenetére
#include <stdio.h>
#include <string.h>
int main()
{
unsigned char stats['z' - 'a' + 1] = {0, };
int duplicate = 0;
int word = 1;
int c;
while((c = getchar()) != EOF) {
if (c == '\n') {
if (duplicate == 0) break;
memset(stats, 0, sizeof stats);
duplicate = 0;
word = 1;
continue;
}
if (c == ' ') {
word = 1;
continue;
}
if (word == 0) continue;
word = 0;
c -= 'a';
if (c < 0 || c >= sizeof stats) continue;
duplicate = (stats[ c ]++ > 0);
}
return 0;
}Hosszt nem ellenőriz, csak angol kisbetűs szavak számítanak és csak szóköz után.
-
#4076
Jester01
veterán
stranger28
#4075
Jester01
veterán
válasz
stranger28
#4075
üzenetére
Aki ezt a specifikációt írta azt fel kellene pofozni
![;]](//cdn.rios.hu/dl/s/v1.gif)
Mi az, hogy stringeket olvas? Sorokat, gondolom, aminek a végén valamilyen soremelés van.
Mit csináljon, ha több mint 30 karakter egy sor?
Hogyan definiáljuk a szavakat? Írásjelekkel mi a helyzet?
Milyen ábécét használjunk - magyart vagy angolt? Előbbi esetén mi legyen a kettősbetűkkel? Kisbetűk és nagybetűk egyformák?Hirtelen csak ennyi problémát látok ami nélkül tulajdonképpen el sem lehet kezdeni.
-
Jester01
veterán
Valóban.
Nem gondoltam, hogy ez így meg van kötve ezért nem is néztem utána.
De most megtettem így még két pont érdekes:An implementation may allocate any addressable storage unit large enough to hold a bit-field.
Tehát még ha el is fogadja a char-t akkor sem kötelező neki abban tárolni.
Továbbá:The order of allocation of bit-fields within a unit (high-order to low-order or low-order to high-order) is implementation-defined.
Vagyis a fenti példában a bit0-7 tagok egyáltalán nem biztos, hogy a névből következő helyiértéknek felelnek meg.
-
Jester01
veterán
válasz
skylaner
#3972
üzenetére
A megjegyzéseket azért tettem, mert a topikot kezdők is olvassák akiknek esetleg hasznos lehet.
Amúgy mi a gond a printf("%c",c)-vel?
Működni működik, csak fölöslegesen küzd szegény gép a %c formátumstring feldolgozásával és még leírni is hosszabb
Egyébként gcc van annyira okos, hogy kicseréli putchar hívásra, tehát ezesetben futásidőben már nincs hátránya (azon túl, hogy esetleg meglepődsz, hová lett a printf hívás). -
Jester01
veterán
válasz
buherton
#3970
üzenetére
A "type" az a teljes prototípus, visszatérési értékkel együtt.
Továbbá:
The effect of program termination in a freestanding environment is implementation-defined.Tulajdonképpen a main ezzel elvesztette a speciális mivoltát. Lehet, hogy nem is ott indul a program, és nem is tudni mit kap és mit ad vissza. Csak egy mezei függvény lett.
-
Jester01
veterán
válasz
buherton
#3968
üzenetére
Igen, a C szabvány ezt meg is említi:
"In a freestanding environment (in which C program execution may take place without any benefit of an operating system), the name and type of the function called at program startup are implementation-defined."Például gcc fordítónak van is rá kapcsolója, -ffreestanding. Ha ezt megadod akkor nem is reklamál a void main miatt.
-
Jester01
veterán
válasz
skylaner
#3958
üzenetére
1. A main visszatérési típusa int.
2. A string literálok típusa const char*.
3. Mivel a függvényed nem módosítja a stringet, oda is const char* ajánlott (különben az előző pont miatt nem tudod beadni a literált).
4. Karakterek kiírására putchar és társai valók.
5. Optimalizációs okokból az osztás általában kerülendő ha máshogy is meg lehet oldani.
6. Nyelveket nem keverjük (a függvényed szoveg_tordelo de a paraméter char_num), lehetőség szerint csak az angolt használjuk. -
Jester01
veterán
válasz
Geresics
#3955
üzenetére
Ez nem jó, először szépen kiszámolod a távolságot de azután nem abból keresed a maximumot:
for (i=0; i<n; i++)
if ((pont[i].x)>max) {
max=pont[i].x;
mem=i;
} else if ((pont[i].y)>max) {
max=pont[i].y;
mem=i;
}Itt miért az x,y-al varázsolsz?
Helyesebben:for (i=0; i<n; i++)
if (tav[i]>max) {
max=tav[i];
mem=i;
}Egyébként ehhez el sem kellene tárolni a pontokat, a maximum távolságot a hozzá tartozó ponttal együtt a bekérő ciklusban is nyilvántarthatod.
Ja és kellene #include <math.h> az sqrt miatt.
-
Jester01
veterán
Az fgets már eleve rajta hagyja a sorvéget, te meg még plusz teszel is ... ehhez képest ha egy sincs az valami mágia:
$ cat >test.c
#include <stdio.h>
void csinal_dat()
{
char puff[256];
FILE *fpt=fopen("kons.txt","rt");
FILE *fpd=fopen("kons.dat","wb");
if (fpt!=NULL)
{
while(fgets(puff,256,fpt)!=NULL)
{
fprintf(fpd,"%s\n",puff);
}
}
else
printf("hibas megnyitas: kons.txt");
fclose(fpd);
fclose(fpt);
}
int main()
{
csinal_dat();
return 0;
}
$ gcc -g test.c
$ echo -e "alma\nnarancs" > kons.txt
$ cat kons.txt
alma
narancs
$ ./a.out
$ cat kons.dat
alma
narancs -
Jester01
veterán
Ha megoldható, akkor a tömböt add át, és a függvényen belül legyen a .adatx. Ez gondolom menne, tehát valamiért nem megvalósítható.
Alternatívaként csinálhatsz accessor függvényt, varázsolhatsz offsetof segítségével avagy ha esetleg véletlen c++ és nem c akkor member pointerrel.
#include <iostream>
using namespace std;
struct Foo
{
int x;
int y;
};
int sum0_x(Foo* array, int count)
{
int r = 0;
for(int i = 0; i < count; i += 1)
{
r += array[i].x;
}
return r;
}
int sum0_y(Foo* array, int count)
{
int r = 0;
for(int i = 0; i < count; i += 1)
{
r += array[i].y;
}
return r;
}
int sum1(Foo* array, int count, int (*accessor)(Foo*))
{
int r = 0;
for(int i = 0; i < count; i += 1)
{
r += accessor(array + i);
}
return r;
}
int sum2(Foo* array, int count, int member)
{
int r = 0;
for(int i = 0; i < count; i += 1)
{
r += *(int*)((char*)(array + i) + member);
}
return r;
}
int sum3(Foo* array, int count, int (Foo::*member))
{
int r = 0;
for(int i = 0; i < count; i += 1)
{
r += array[i].*member;
}
return r;
}
int accessor_x(Foo* foo)
{
return foo->x;
}
int accessor_y(Foo* foo)
{
return foo->y;
}
int main()
{
Foo foos[2];
foos[0].x = 1;
foos[0].y = 2;
foos[1].x = 3;
foos[1].y = 4;
cout << "sum0(x) = " << sum0_x(foos, 2) << endl;
cout << "sum0(y) = " << sum0_y(foos, 2) << endl;
cout << "sum1(x) = " << sum1(foos, 2, accessor_x) << endl;
cout << "sum1(y) = " << sum1(foos, 2, accessor_y) << endl;
cout << "sum2(x) = " << sum2(foos, 2, offsetof(Foo, x)) << endl;
cout << "sum2(y) = " << sum2(foos, 2, offsetof(Foo, y)) << endl;
cout << "sum3(x) = " << sum3(foos, 2, &Foo::x) << endl;
cout << "sum3(y) = " << sum3(foos, 2, &Foo::y) << endl;
return 0;
} -
Jester01
veterán
-
-
Jester01
veterán
Ezzel több baj is van.
Ha egyáltalán nem működik az azért lehet mert nem jó a bemenet. Ha tényleg "45+15" akkor azt egyben megeszi az első scanf. Kell közéjük valami elválasztó whitespace, például "45 + 15". Ezután az lesz a következő baj, hogy simán az ascii kódot nem lehet összeadni, le kell vonni belőle 0 ascii kódját. Ha ez is megvan akkor még az átvitel (carry) problémáját is meg kell oldani. Az eredmény hosszával is gondok vannak, te egyszerűen az első szám hosszát használod ami nem (mindig) jó. -
#3748
Jester01
veterán
robotjatek
#3747
Jester01
veterán
válasz
robotjatek
#3747
üzenetére
Vagyis polinomkiértékelő? Eléggé 5 perces melónak hangzik.
-
#3703
Jester01
veterán
PumpkinSeed
#3702
Jester01
veterán
válasz
PumpkinSeed
#3702
üzenetére
Beolvasod az egész sort fgets-el majd strtol vagy sscanf segítségével felbontod. Ha nem tetszett amit kaptál akkor újra olvasol egy sort. Bónusz pontért lekezeled azt is, ha túl hosszú sort ír be az ember.
-
#3675
Jester01
veterán
PumpkinSeed
#3674
Jester01
veterán
válasz
PumpkinSeed
#3674
üzenetére
-
#3672
Jester01
veterán
PumpkinSeed
#3671
Jester01
veterán
válasz
PumpkinSeed
#3671
üzenetére
Sokat ivott és hülyeségeket írkált
-
-
Jester01
veterán
-
Jester01
veterán
A scanf("%s") ugyanúgy nem ellenőrzi a hosszt, tehát túlcsordulás veszélyes.
Hogy a program miért nem működik azt már a #3603-ban leírtam. A scanf hagyja a pufferben a sorvéget ezért a rákövetkező fgets üres sort lát. A mostani kóddal ezért a település neve lesz üres.
Az ember azt hinné az adatbevitel egyszerű, de ez sajnos nem így van
Mivel mindenhol sorokat akarsz olvasni, mindenhol fgets kell és máris jó lesz. Persze igazából egy hibakezelős verzió kellene, ami észreveszi, ha több betűt ír be a lökött felhasználó.
Például valami ilyesmi jöhet szóba.
-
Jester01
veterán
mert a gets az stdin pufferben hagyja az újsor karaktert
Elvileg (és nálam gyakorlatilag) nem hagyja ott. De a scanf meg amúgy is megeszi automatikusan.Egyébként gets-et tilos használni, fővesztés terhe mellett. Helyette fgets ajánlott.
MOD: Konkrétan a település nevét bekérő scanf hagyja a pufferben a sorvéget, így a gets fog üreset adni és a közterület marad ki, nem a házszám.
-
Jester01
veterán
-
Jester01
veterán
válasz
Bobrooney
#3523
üzenetére
Ez is több sebből vérzik.
1. puffer túlcsordulás
2. egyébként is a puffer tök fölösleges
3. a getchar visszatérési értéke nem char
4. fájl végét nem '0' jelziEsztétikai kifogások
1. az if/elseif/else szerkezetet úgy hívják, switch
2. a '\0' az olyan mint az "artist formerly known as Prince" ... az a karakter aminek a kódja 0 ... akkor már miért nem mondod hogy 0. -
Jester01
veterán
válasz
sztanozs
#3498
üzenetére
Azért, hogy a kezdőket ne vezessük félre megjegyzem, hogy ez a megoldás nem teljesen tökéletes. A baj nem a konverzióval van, hanem azzal, hogy a string literálok nem írhatók. Tehát ez rossz: char* binary = "0000|0000|0000|0000"; és persze ez is binary[counter] = '1';
-
Jester01
veterán
Na nem azért nem szabványos
C szabvány, 6.5.2 bekezdés:Between the previous and next sequence point an object shall have its stored value modified at most once by the evaluation of an expression. Furthermore, the prior value shall be read only to determine the value to be stored.
This paragraph renders undefined statement expressions such as
i = ++i + 1;Márpedig az adott kódban ilyenek vannak.
Egyébiránt GCC meg is mondja:
ph.c: In function 'main':
ph.c:5: warning: operation on 'b' may be undefined
ph.c:5: warning: operation on 'a' may be undefined
ph.c:10: warning: operation on 'd' may be undefined
ph.c:10: warning: operation on 'c' may be undefined -
Jester01
veterán
válasz
Retekegér
#3369
üzenetére
conio.h és getch nem szabványos, arra van a getchar amit mellesleg a csúnya scanf helyett is használhatsz.
Ha a while ciklus már elérte a végét, akkor a getch már amúgy is fölösleges.
A tömb elem növelésénél pedig nem i-t hanem c-t kellene használni indexeléshez.
Ezen felül ajánlott kapcsoszárójeleket és áttekinthetőbb struktúrát használni.
Ja és nem formázott kiíráshoz fölösleges a printf, arra van a puts.A ctrl+z pedig elképzelhető, hogy csak üres sorban fog működni (legalábbis a linuxos ctrl+d így van) tehát előbb enter kell az aktuális sor lezárásához majd jöhet az EOF.
#include <stdio.h>
int main ()
{
int c;
int i;
int tomb[10];
puts("Fajl vege jelig (Ctrl+Z) szabvanyos bementrol olvasva");
puts("megszamoljuk, hogy hany szamjegy van a szovegben.\n");
for (i=0; i<10; i++) {
tomb[i]=0;
}
while ((c = getchar()) != EOF) {
if (c>='0' && c<='9') {
tomb[c-'0'] += 1;
}
}
for (i=0; i<10; i++) {
printf("%d: %d\n",i,tomb[i]);
}
return 0;
} -
Jester01
veterán
Rögtön az elején kezdődnek a bajok:
open("/dev/input/uinput", O_WRONLY) = -1 ENOENT (No such file or directory)
Egész egyszerűen nincs ilyen eszköz, például nincs benne a kernelben vagy nincs betöltve a szükséges modul.A kód valóban gány, mert 0 ellenőrzés van benne, pedig az open nem nullát ad vissza hiba esetén, hanem -1-et.
ufile = open("/dev/input/uinput", O_WRONLY);
if (ufile == 0) {
printf("Could not open uinput.\n"); -
-
-
Jester01
veterán
válasz
shinodas
#3318
üzenetére
A két return-nek nincs értelme.
A *magan_p++; pedig nem az értéket növeli, hanem a pointert. Helyesen (*magan_p)++; MOD: illetve a talán olvashatóbb *magan_p += 1; forma. Nyilván ugyanez vonatkozik a massal_p-re is.Érdemes a fordító figyelmeztető üzeneteit bekapcsolni és átgondolni. Jelen esetben például:
t.c: In function 'massal_magan':
t.c:86: warning: value computed is not used
t.c:89: warning: value computed is not used
t.c:96: warning: will never be executedJa egyébként nem minden mássalhangzó ami nem magánhangzó (például a szóköz, számok, írásjelek)
-
Jester01
veterán
válasz
shinodas
#3206
üzenetére
A srand inicializálja a véletlenszám generátort valami kiinduló érték alapján. Azonos kiindulási értékből mindig azonos sorozat lesz (debuggoláshoz jó például). Hogy mindig más legyen, az aktuális idő van megadva.
A rand() az visszaad egy egész számot a [0, RAND_MAX] intervallumból. A % az nyilván a maradékképzés, tehát végül is a [0, 8] intervallumban fogsz számokat kapni.
-
-
Jester01
veterán
Equal-sized az értékkészletben. Nem azonos elem számosságú. Legalábbis a mellékelt kód szerint. Pl itt látszik:
// Calculating the size of each bin; this takes roughly 10% of runtimeVégigmegy az elemeken és megnézi melyik bin-be kerülnek, aztán a bin-ek kezdőpozíciót a számosságok alapján számolja ki.
-
Jester01
veterán
A lényeg ott lenne, hogy a min és max elemek közé úgy pakoljuk be az elemeket, hogy valamilyen csoportosításba kerüljenek mint a BucketSortnál pl 10-20, 20-30, 40-50- ig stb.
Igen, ez így történik. Mivel az értéktartományt osztja szét részekre és az elemeket szétdobálja. Utána pedig az egyes részeket is berendezi. A két rendezésből az egész rendezve lesz. Az intervallumok viszont nem lesznek egyenlő számosságúak.
-
Jester01
veterán
mivel java, C#-on nevelkedtem és itt jobbra balra bitshiftelnek ha jól látom
Ez aztán a jó kifogás
Mintha azokban a nyelvekben nem lenne bit shift.A rövid kis leírás pont elmeséli hogyan működik. Veszi a tömböt, megkeresi a legkisebb és legnagyobb elemeket. Az így megkapott intervallumot elosztja egyenlő részekre majd ezeket a részeket rekurzívan rendezi. A rekurzió során bizonyos elemszám alatt már másfajta rendezést használ.
-
Jester01
veterán
válasz
hruodnand
#3117
üzenetére
Eddig is "jó" volt, még mindig nem láttam olyan kódot ami rosszul működött volna.
Mostantól viszont minden egyes írás/olvasás a memóriába megy, akár optimalizálsz akár nem (megkötötted a fordító kezét). Ez jelen helyzetben gondolom nem probléma, de azért ezt ne tanuld meg. Azt viszont tanuld meg, mit csinál a volatile, hátha megkérdezik miért tetted oda
-
Jester01
veterán
válasz
ArchElf
#3105
üzenetére
Igen, lehet hogy az egész arról szól, hogy a kolléga elfelejtette kikapcsolni az optimalizációt.
hruodnand: úgy értettem, hogy ha a program működése szempontjából lényegtelen a kezdőérték, akkor a fordítónak nem muszáj nulláznia.
Mellesleg aggresszívabb optimalizáció mellett (linuxon!) az egész ciklus eltűnik a fenébe tömböstül mindenestül - mivel nincs használva. Ellenőrizd az optimalizációs beállításokat.
-
Jester01
veterán
Mondjuk azért mert egyiket sem nullázza ki, csak a memória egy része véletlen pont nulla. Attól függően melyik tömb kerül oda, lesz nulla vagy nem.
hruodnand: ami kódot mutattál az csak írja a tömböt. Tehát mindegy mi a kezdőértéke. A debuggolásról meg a fordító előre nem tud.
-
-
Jester01
veterán
válasz
Rickazoid
#3085
üzenetére
Az i nem feltélten lesz 0. Egyszerűen csak nem változik az értéke. Mivel te semmivel sem inicializáltad, véletlen érték lesz, ami éppen a memóriában volt. Feladattól függően egyébként sem biztos, hogy a 0 hibás bevitel lenne.
Azért végtelen a ciklus mert ha a scanf elakad, akkor nem olvassa ki a pufferből a maradékot. A következő scanf hívás tehát pont ugyanúgy elakad. Neked kell takarítani, a következő sorvég jelig, például getchar használatával. EOF-ot is illik lekezelni.
A scanf amúgy visszaadja mennyi mezőt sikerült beolvasnia, de ettől még lehet szemét a pufferben. Nem véletlenül mondják, hogy nem ajánlott scanf-et használni. Bármennyire is nem szeretnéd, a korrekt megoldás általában teljes sor olvasása (fgets) után kézi feldolgozás (strtol, strtod).
-
Jester01
veterán
Az értékadás mint kifejezés inkább feltételben szokott előfordulni, ilyesmiket lehet gyakrabban látni:
while ((c = fgetc(in)) != EOF) { ... }
vagy
while ((bytes = read(...)) > 0) { ... }Ezekben az esetekben olvashatóbbá teszi a kódot, artiny verziójában valóban fölösleges, inkább zavaró volt.
-
Jester01
veterán
Van több is
while(d != '1');
Ide nem karakter konstans kell, csak simán egy szám.Másik probléma, hogy a d-be számítod ki az új értéket de az a-t használod.
Kicsit letisztázva ilyesmi lehet:
#include <stdio.h>
int main(void)
{
int a;
scanf("%d",&a);
do
{
if (a % 2 == 0)
{
a = a / 2;
} else {
a = a * 3 + 1;
}
printf("%d\n", a);
} while (a != 1);
return 0;
} -
#3044
Jester01
veterán
WonderCSabo
#3043
Jester01
veterán
válasz
WonderCSabo
#3043
üzenetére
Azok közül csak a gets vár entert, a többinél csak azért látszik úgy, mert az alatta lévő réteg eleve soronként pufferel. Ennek kikapcsolása vagy megkerülése sajnos platformfüggő.
-
#3039
Jester01
veterán
WonderCSabo
#3038
Jester01
veterán
válasz
WonderCSabo
#3038
üzenetére
Főleg, hogy ennek olyan szaga van, hogy valakivel megíratta a tanár meg lebuktatta...
-
Jester01
veterán
Ahogy mondod
Mivel a main a kapcsolat a futo és a futolepes között, így először futo-ból kellene visszaadni a main-be, majd onnan tovább. A helyzetet bonyolítja, hogy 2 értékről van szó. Egy lehetséges megoldás ha definiálsz egy struktúrát a két értéknek és azt adogatod, valahogy így:struct pozicio
{
int sor;
int oszlop;
};
struct pozicio futo(char tabla[TABLA_MERET][TABLA_MERET], char input[3])
{
struct pozicio p;
...
return p;
}
...
void futolepes(char tabla[TABLA_MERET][TABLA_MERET], struct pozicio p)
{
...
}
...
int main()
{
struct pozicio p;
...
p = futo(tabla, input);
gyalog(tabla, input);
futolepes(tabla, p);
...
}A naív megoldás persze a globális változók használata lenne, de az általában nem ajánlott.
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Egyébként gcc van annyira okos, hogy kicseréli putchar hívásra, tehát ezesetben futásidőben már nincs hátránya (azon túl, hogy esetleg meglepődsz, hová lett a printf hívás).
szerint 1 kell.Ú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!
- SanDisk Extreme Portable 8TB (SDSSDE61-8T00-G25)
- AKCIÓ! Gigabyte B450M R7 2700X 16GB DDR4 512GB SSD RX VEGA64 8GB CM 690 III FSP 600W
- Bomba ár! HP Elitebook 8560W - i7-2GEN I 8GB I 500GB I 15,6" FHD I Nvidia I W10 I Garancia
- Bomba ár! Dell Latitude 5430 - i7-1255U I 16GB I 512SSD I HDMI I 14" FHD I Cam I W11 I NBD Garancia!
- Bomba ár! Dell Latitude E6400 - Intel P8400 I 3GB I 160GB I 14,1" I Intel VGA I Garancia!
Állásajánlatok
Cég: CAMERA-PRO Hungary Kft
Város: Budapest
Cég: Promenade Publishing House Kft.
Város: Budapest