Hirdetés
- Milyen asztali (teljes vagy fél-) gépet vegyek?
- Októberben kerülnek legacy státuszba a régebbi GeForce VGA-k
- Milyen billentyűzetet vegyek?
- LG LCD és LED TV-k
- AMD Ryzen 9 / 7 / 5 9***(X) "Zen 5" (AM5)
- NVIDIA GeForce RTX 5080 / 5090 (GB203 / 202)
- Milyen belső merevlemezt vegyek?
- És akkor egy fejlesztőstúdió rájött, hogy vissza is élhetne a felskálázással
- Mini PC
- Nvidia GPU-k jövője - amit tudni vélünk
Hirdetés
Köszönjük a sok biztatást, támogatást! Egy rövid ideig még féláron tudsz hirdetni, előfizetni!
Új hozzászólás Aktív témák
-
cog777
senior tag
Mint c++ fejleszto, lenne par kerdesem c-vel kapcsolatban. Eleg regen foglalkoztam c-vel, most kaptam par feladatot, kapasbol a c++-os mintak jutottak eszembe, de aztan felvetodott bennem, hogyan oldanam meg a feladataimat c-ben?
Egyik feladat igenyli a dependency injection-t, amikor egy kliens kod hasznalni akar valamilyen implementaciot, pl driver-t.
Ekkor c++-ban csinalok egy interface osztalyt, majd abbol orokoltetem. Az interface osztalyon keresztul at lehet adni a driverA-t es a driverB-t is. Helyzettol fuggoen.
Na most, c-ben ezt hogy lehetne megoldani?
Alap esetben csinalnek egy csomo fuggvenyt ami a driver-t elinditja, es ezek a fuggvenyek ertelemszeruen elerhetok lennenek. De ilyenkor nem tudom barmikor kicserelni a driver funkcioit a kliensben hacsak at nem irom...
Esetleg atadok egy strukturat, amiben fuggvenyre mutato pointerek vannak es azt meg a kliens inicializalasa elott feltoltom annak megfeleloen hogy vagy a driverA, vagy driverB-nek a funkcioit akarom hasznalni a kliensben?
Remelem ertheto a problemam... szoval mi lehet a "dependency injection" c-ben? -
buherton
őstag
Lenne egy számomra fogós kérdés.
Az alábbi kódrészletben miért biztos mindenki, hogy a pointer majd az inkrementált címre fog mutatni az értékadáskor az alábbi kódrészletben?
*p++ = 1;Keresem az okot a miértre, de őszintén nem találom. Annyit sikerült kideríteni, hogy nem a precedencia az ok.
A C99 szabványban (alább a részletek) úgy értelmezem, hogy ténylegesen bármikor megtörténhet két sequence point között.
Ráadásul ez a leírás is csak ráerősít arra, hogy az order unspecified: [cpp reference - Order of evaluation]
Segítene valaki felhomályosítani ebben az ügyben?
-
kovisoft
őstag
-
buherton
őstag
válasz
pmonitor
#6235
üzenetére
[centralized-exiting-of-functions]
vagy
int __init my_init_function(void) {int err;/* registration takes a pointer and a name */ err = register_this(ptr1, "skull");if (err) goto fail_this;err = register_that(ptr2, "skull");if (err) goto fail_that;err = register_those(ptr3, "skull"); if (err) goto fail_those;return 0; /* success */fail_those: unregister_that(ptr2, "skull");fail_that: unregister_this(ptr1, "skull");fail_this: return err; /* propagate the error */}amikor nem tudtad másképp megoldani?
Jaj, az annyira olyan ez a kérdés. Lehet programozni if-else nélkül is. Lehet programozni for, while, do-while nélkül is, de nyilvánvalóan nem érdemes. -
kovisoft
őstag
válasz
DopeBob
#6140
üzenetére
Megpróbáltam lefordítani az eredeti kódodat, de nekem (treat warnings as errors beállítással) fordítási hibát dobott a scanf és a printf sorokra. Érthető, mivel az int (*statData)[statDay][OPEN_HOURS] egy kétdimenziós tömbre mutató pointer, nem pedig egy kétdimenziós tömb. A statData[i][j] nem egy int-et, hanem egy pointert jelent. Cast-olással kierőszakoltam, hogy leforduljon, valamint felcseréltem a statData deklarációjában a sorokat és az oszlopokat (int (*statData)[OPEN_HOURS][statDay]), és így már ez a változat is működött.
Ökölszabályként azt tartsd szem előtt, hogy amikor egy pointert deklarálsz, akkor azt tömbként is tudod használni (meg tudod indexelni [i] stílusban), tehát úgy is felfogható a dolog, hogy egy * ugyanúgy hozzáad egy dimenziót a deklarált tömbödhöz, mint egy [SIZE]. Fordítva is igaz a dolog: egy tömb utolsó dimenzióját lehagyva egy pointert kapsz.
Vagyis amikor ezt írod le: int (*statData)[OPEN_HOURS][statDay], akkor ez igazából egy 3 dimenziós tömb, aminek az első két dimenziója a fix [OPEN_HOURS] és [statDay], a harmadik dimenziója dinamikus, és ennek mérete a malloc-ban megadott értékből jön, ami jelen esetben [1] (mivel a teljes allokált méret OPEN_HOURS*statDay*1). Éppen ezért az így deklarált tömb elemeire ezen a módon kell hivatkozni: statData[i][j][0]. Kipróbáltam ezt is, és így is működik. Ezzel együtt nem javaslom ennek a formának a használatát, és nem is értem, hogy a Pluralsight miért így tanítja.
-
kovisoft
őstag
válasz
DopeBob
#6138
üzenetére
Amikor egy szimpla 1 dimenziós tömböt allokálsz, akkor azt egy szimpla pointerbe rakod bele:
int *array = malloc(sizeof(int[ARRAY_SIZE]));És utána array[i]-vel hivatkozol az elemeire. Ha ezt ki akarjuk terjeszteni 2 dimenzióra, akkor hozzáteszünk mindkét oldalhoz +1 dimenziót, de miért tennénk +2 dimenziót a bal oldalhoz?
int (*twod_array)[COLUMNS] = malloc(sizeof(int[ROWS][COLUMNS]));Így a twod_array egy olyan pointer, ami "COLUMNS db integerből álló tömb" típusú adatra mutat, ilyenekből allokáltunk ROWS db-ot, és twod_array[i][j]-vel hivatkozunk az elemeire. Legalábbis szerintem így kell, de bevallom, nem próbáltam ki.
Viszont mint írtam, csinálhatod azt is, hogy te számolod át a 2 dimenziós indexet 1 dimenziósra, ekkor elég egy nagy 1 dimenziós tömböt allokálni:
int *simulated_twod_array = malloc(sizeof(int)*ROWS*COLUMNS);Aztán így hivatkozol az i. sor j. oszlopára: simulated_twod_array[i*COLUMNS+j].
-
DopeBob
addikt
válasz
kovisoft
#6137
üzenetére
Megnézem, de ennél a résznél kezdem elveszteni már a fonalat
Pluralsight-on csinálom a C képzéseket, pont azt monta az oktató ennél a résznél, hogy ez a legegyszerűbb módja mert egyszerű utána felszabadítani a memóriát, és ugyan úgy lehet hivatkozni egy elemet, ahogy statikus 2D tömbnél. Neten- YT-n mindenhol a for ciklussal feltöltögetős verziót láttam, azért örültem meg ennek, de hát nem megy.
Amit írtál azt hogy kell elépzelni, nem teljesen értem. Egy sort ki tudok választani egy pointerre és egy elemet egy indexel?
-
kovisoft
őstag
válasz
DopeBob
#6136
üzenetére
Szerintem a malloc sorral van a gond. Ahogy írtad, úgy eggyel több az indirekció a bal oldalon (pointer egy két dimenziós tömbre, ami így egy három dimenziós tömbbel lesz analóg). Helyette ez kellene:
int (*statData)[statDay] = malloc(sizeof(int[statDay][OPEN_HOURS]));Másik lehetőség, hogy egy dimenziós tömböt használsz (szimpla pointert allokálsz) és [i*OPEN_HOURS+j] formában indexeled.
És a free-nél sem kell a csillag, csak simán free(statData).
-
kovisoft
őstag
válasz
#90088192
#6104
üzenetére
Persze, teheted a font paramétereket egy struktúrába, és akkor elég átadni erre a struktúrára mutató pointert a font választáshoz (vagy csúnyább esetben mehet az egész egy globális változóba). Pl:
#include "font1.h"
#include "font2.h"
struct font_type
{
long int *font;
int font_width;
int font_height;
int font_offset;
};
struct font_type myfont[2];
myfont[0].font = Font1;
myfont[0].font_width = Font1_width;
myfont[0].font_height = Font1_height;
myfont[0].font_offset = Font1_offset;
myfont[1].font = Font2;
myfont[1].font_width = Font2_width;
myfont[1].font_height = Font2_height;
myfont[1].font_offset = Font2_offset;
int write_char(int page_select, int y_offset, int character_code,struct font_type *use_font)
{
...
send_data_screen(use_font->font);
...
}
write_char(line,y_offset+j*myfont[0]->font_width,test[j],&myfont[0]);
write_char(line,y_offset+j*myfont[1]->font_width,test[j],&myfont[1]);De lehet, hogy jobb lenne az y_offset paramétert szétszedni egy y és egy j paraméterre, és a font_width-tel való szorzást beletenni a függvénybe, hogy ne kelljen azt is font-tól függően átadni:
int write_char(int page_select, int y, int j, int character_code,struct font_type *use_font)
{
int y_offset = y+j*use_font->font_width;
...
send_data_screen(use_font->font);
...
} -
#90088192
törölt tag
Hello Mindenkinek
Segítséget szeretnek kerni, falba ütköztem, de nem értem miért.
../screen.c: In function 'put_pixel':
../screen.c:128:35: error: invalid operands to binary | (have 'int (*)(void)' and 'int')
send_data_screen(data_read | (BASE_ADDRESS_PIXEL << x%Display_pages));Maga a probléma, amit addig értek(?), hogy nem lehet bináris műveletet elvégezni pointeren.
Azt nem értem miért lett az pointer
A program részletek amik relevánsak(Elnézést még nem kommenteltem az új szekciót mert nem működik):
int data_read(void)
{
int data_in;
DISPLAY_RS = 1;
DISPLAY_RW = 1;
DISPLAY_DATA_DIRECTION = 1;
DelayUs(Hardware_delay*2);
data_in = S_DATA_IN;
DelayUs(Hardware_delay*4);
DISPLAY_DATA_DIRECTION = 0;
return(data_in);
}
int send_data_screen (long int Data_out) //Sends Data to the Display hardware
{
if(Data_out<=(Dislpay_height/Display_pages)*(Display_width/2) ) //Checks is the data length is valid
{
DISPLAY_EN = 0; //Turns Display Off
DISPLAY_RS = 1; //Enables Data mode
DelayUs(Hardware_delay);
S_DATA_OUT = Data_out; //Insert Data to the hardware line
strobe_E(); //Turns Display On/off
DISPLAY_RS = 0; //Disables Data mode
}else{
return(1);
}
}
int put_pixel(int x, int y)
{
if(x>=0 && x<=63 && y>=0 && y<=127)
{
goto_xy(x/Display_pages,y);
send_data_screen(data_read | (BASE_ADDRESS_PIXEL << x%Display_pages));
}else{
return(1);
}
} -
#6067
jattila48
aktív tag
borisz1994
#6064
jattila48
aktív tag
válasz
borisz1994
#6064
üzenetére
Ahogy többen írták, deklarációra akkor van szükség, ha egy változót, függvényt, vagy típust előbb akarsz használni, mint ahogy definiálnád. Lokális változóknál nincs különbség, ott a deklaráció egyben helyfoglalással is jár. Főleg globális változók és körbe hivatkozások használatakor kell külön deklarálni, és defniálni. Globális változó deklarálása az extern kulcsszóval történik.Valamelyik fordítási egységben ennek definiáltnak kell lenni, a többi, rá hivatkozó TU-ban pedig extern-nel deklaráltnak kell lenni. Függény deklarációjánál extern kulcsszóra nincs szükség (bár megadható). C-ben a függvények mindig globálisak (nincs lokális fv. ellentétben néhány más programozási nyelvvel). Az előre deklarálást nem tudod elkerülni (program szöveg átrendezéssel), ha körbe hivatkozás van (pl. f fv. hívja g-t,ami hívja f-et). Ilyenkor valamelyiket mindenképp előre kell deklarálni (ezt hívják fv. prototipusnak), aminek a tényleges definícióját (a fv. kódját) csak a másik fv. definíciója után tudod megadni. Fontos eset még a struktúrák előre deklarálása. Ezt is a körbehivatkozás teszi szükségessé (pl. rekurzív adatszerkezetek), hasonlóan, ahogy fv.-ek esetén is. A struktúra definíciója hivatkozik B stuktúrára, ami szintén hivatkozik A-ra. Ekkor azonban a csak előre deklarált struktúra típus nem teljes értékű (hiszen még nem ismerjük a szerkezetét), ezért csak rá mutató pointer típus deklarálható a hivatkozó struktúrában. Az ilyen típust incomplete type-nak hívják.
-
jattila48
aktív tag
válasz
jattila48
#6035
üzenetére
Közben rájöttem, mikor van értelme a tömbre mutató pointer használatának.
int iia[10][5];
int (*piia)[5];
piia=iia;
Az iia kétdimenziós tömb neve önmagában leírva nem int ** típusú, hanem int (*)[5] típusú. Ezért ha ezt a kétdimenziós tömböt akarjuk átadni az f fv.-nek, akkorvoid f(int (*x)[5]);
prototípusúnak kell lennie. -
jattila48
aktív tag
válasz
kovisoft
#6034
üzenetére
A baj csak az, hogy a tömbre mutató pointerhez hozzá van kötve a tömb mérete. Tehát, ha a tömbre mutató ponter egy fv. argumentuma, akkor annak semmilyen más méretű tömböt nem lehet átadni. Így aztán a tömb méretét lekérdezni nem sok értelme van, hiszen ez a fv. csak ilyen méretű tömböt képes fogadni.
Nem vitatkozni akarok, csupán érdekel, hogy miért létezik ez a konstrukció a C nyelvben. Akkor lenne értelme, ha nem lehetne elkerülni a használatát, vagy az elkerülése bonyolultabb lenne. Ehelyett mindig el lehet kerülni, és egyszerűbben, mint használni. Pointereket leggyakrabban azért haználunk, hogy az általuk mutatott memória címen megváltoztassuk a memória tartalmát (vagy mert a stack-en nem lehet nagyméretű objektumokat átadni). Ehhez képest a tömbre mutató pointeren keresztül nem változtatjuk meg a tömböt (ami itt a tömb címét jelenti), hiszen az nem is balérték. Úgy tűnik, hogy igazából semmi értelme nincs, mindössze a C típusdefiníciós szintaxisának egy csökevénye. -
kovisoft
őstag
válasz
jattila48
#6033
üzenetére
Ha pia egy másik függvényben van, akkor ott nem látod az eredeti tömböket. Lehet pl. pia egy függvény paramétere, és fontos, hogy szigorúan egy adott méretű tömb legyen neki átadva.
Egyébként ha ez most már arra megy ki, hogy hogyan lehet elkerülni tömbre mutató pointer használatát, arra én is tudok módszereket mondani, ilyen vitában nem kívánok részt venni. De eredetileg mintha azt kérdezted volna, hogy mire lehet használni. Továbbra is az a válaszom, hogy olyan esetben, amikor számít a megcímzett tömb sizeof-ja.
-
jattila48
aktív tag
válasz
kovisoft
#6032
üzenetére
Ha több ugyanolyan típusú tömböt egységesen akarok kezelni, akkor:
int ia1[5],ia2[5];
int *pia;
pia=ia1;
//valamit csinálok a pia pointeren keresztül
pia=ia2;
//stb...Ha a méretükre van szükségem, akkor
ARRAYSIZE(ia1),
de még egyszerűbb, ha#define ASIZE 5
int ia1[ASIZE],ia2[ASIZE];
... -
-
jattila48
aktív tag
válasz
Domonkos
#6024
üzenetére
Ha megnézed, a getopt paramétere char *[] típusú, nem pedig (char *)[] típusú. A két típus különböző. Én az utóbbit kérdezem. Az első címeket tartalmazó tömb, vagyis az elemei pointerek. A második pedig tömbre mutató pointer, aminek értéke a tömb címe. Régóta programozok C-ben, tudom mire való az argv, getopt és társai. De ez más.
-
kovisoft
őstag
C-ben nem tudsz így stringeket összehasonlítani, mert a kar != "end" a két stringre mutató pointert hasonlítja össze, nem pedig a stringek tartalmát. Használd az strcmp() függvényt stringek összehasonlítására (vagy strcmpi-t, ha nem számít a kis-nagybetű):
} while (strcmp(kar, "end") != 0); -
#5935
f(x)=exp(x)
őstag
f(x)=exp(x)
őstag
Sziasztok!
Van itt valaki, aki tudna nekem segíteni pár dologban? Konkrétan írtam egy egyszerűbb programot, és annak egyes részeit át kellene formázni úgy, hogy legyen benne pointer, struktúra. Nem kérem természetesen, hogy bárki megcsinálja helyettem, csak ötletet szeretnék, hogy hol célszerű ezt megtenni a programon belül.
Privát üzenetben átmásolom a konkrét programomat (egyszerű matematikai problémát megoldó programról van szó).
Előre is köszönök minden segítséget!
-
kovisoft
őstag
Milyen hosszú sorok vannak a file-ban, aminek a sorait olvasod? Mert a char sor[128] tömbbe fgets(sor,255,fajl) utasítással 255 karaktert is beolvashatsz, ami aztán felülírhatja a stacket, és lehet ettől is az elszállás. Ill. hány sorból áll a file, mi van, ha nincs benne a szükséges 4 sor?
Másik megjegyzés: ebben a sorban sizeof(Kerdes*) kellene, mert pointer-tömböt foglalsz le. Persze gondot nem fog okozni, ha fölöslegesen foglalsz több memóriát, csak pazarlás:
Kerdes **tomb=(Kerdes**) malloc(15*sizeof(Kerdes));
Egyebek: nincs felszabadítva a lefoglalt memória, nincs lezárva a megnyitott file, de elszállást ezek sem okoznak, csak ha már túl sok leff foglalva/megnyitva.
Szerk: jól látom, közben megoldódott a probléma?
-
buherton
őstag
Nekem eddig egyszer sikerült két csillagos pointert leírnom a saját kódban, mert azzal volt a leghatékonyabb. Különben mindig kerülöm a használatát, mert az ember gyorsan bele tud zavarodni. Ezt javaslom neked is. A Linux függvényei közül is eddig csak eggyel találkoztam, amit két csillagot várt: scandir
u8b data[] -> ez nagyon csúnya.
Mitől csúnya? Inkább u8b* data legyen? Még előnybe részesítem a tömböket a pointerekkel szemben, mivel azokat könnyebben kezelem. 8bites uC-n is könnyebben nyomon tudom követni, hogy mennyi RAM-ot is használok...u8b data[] -> ezzel fölöslegesen foglalsz 512 bájtot a stacken, ami ugye még processzor idő is. Használj pointert. (Egy ilyen miatt én simán buktatnék egyetemen.)
A fordítótól függ, hogy hogyan align-olja a structúra változóit. Bár ez 8 bites, így nem valószínű, hogy máshogy align-olna, de a hordozhatóságot javítja.
, majd ha másolom/küldöm az adatcsomagot akkor a b[]-t használom.
Másolás ->memcpy, küldés bájtonként pedig char*-al tudsz küldeni. Ergo nem kell a union. Nem is értettem az elején, hogy miért is kellett.
dns_answer*& dns_response
Szerintem így sokkal olvashatóbb és nem utolsó sorban sokkal helytakarékosabb és gyorsabb.
void get_data_from_dns_reply(u8b* data, dns_header* dns_resp_header, dns_answer*& dns_response)
{
memcpy(dns_resp_header, data, 12);
dns_response = (dns_answer*)malloc(htons(dns_resp_header->answer_rrs.i) * sizeof(dns_answer));
for(; data[i] != 0; i++)
{
i += data[i];
}
i += 5;
for(u16b j = 0; j < htons(dns_resp_header->answer_rrs.i); j++)
{
i += 12;
memcpy(dns_response[j].data, &data[i], 4);
i++;
}
}MOD: ezen a kódon még bőven lehetne optimalizálni, csak nem látom a többi részt.
MOD2: jah és igen. Malloc + 8 bites MCU? Remélem fut valamilyen OS ezen program alatt, ami a fizikai memóriát rendezi, mert az ilyen malloc-olás magában hordozza azt, hogy a kész programod egyszer beáll, mint a szög. A beágyazott rendszerben alapvetően tiltott a malloc használata.
-
G.A.
aktív tag
válasz
buherton
#5850
üzenetére
Köszönöm a gyors választ.
dns_answer local_answer -> ez nincs használva.
dns_response -> nincs deklarálva.
local_dns_resp -> nincs deklarálva.
...
dns_answer** answer -> ezt nem használod semmire.A problémás kódrészt próbáltam leegyszerűsítve a hozzászólásba beírni, közben sikerült nekem is belezavarodnom és elírnom.
dns_answer local_answer = local_dns_resp
dns_answer** answer = *dns_responseu8b data[] -> ez nagyon csúnya.
Mitől csúnya? Inkább u8b* data legyen? Még előnybe részesítem a tömböket a pointerekkel szemben, mivel azokat könnyebben kezelem. 8bites uC-n is könnyebben nyomon tudom követni, hogy mennyi RAM-ot is használok...A struct-hoz erősen javaslok egy packed attribute-omot.
Hobbi programozóként nem tudom mit jelent... mire használható.Minek union?
Megint uC-re hivatkozok. Anno #define-t használtam egy tömb változóinak az azonosításához. Ezt cseréltem le unionba ágyazott struktúrákkal. Így értem:typedef union udpv4_header
{
struct
{
my_16b src_port;
my_16b dst_port;
my_16b length;
my_16b checksum;
};
u8b b[8];
}udpv4_header;
A struktúrát használom egy konkrét változó módosításához, majd ha másolom/küldöm az adatcsomagot akkor a b[]-t használom.miért is nem memcpy-k?
Szintén egy hiányosságom. Még nem tanultam meg a használatát...Közben szerintem meglett a megoldás(működik). Ez lett a function() módosított kódja:
void get_data_from_dns_reply(u8b* data, dns_header* dns_resp_header, dns_answer*& dns_response)
{
u8b i = 0;
for (; i < 12; i++)
{
dns_resp_header->b[i] = data[i];
}
dns_response = (dns_answer*)malloc(htons(dns_resp_header->answer_rrs.i) * sizeof(dns_answer));
for(; data[i] != 0; i++)
{
i += data[i];
}
i += 5;
for(u16b j = 0; j < htons(dns_resp_header->answer_rrs.i); j++)
{
i += 12;
for (u8b x = 0; x < 4; x++, i++)
{
dns_response[j].data.b[x] = data[i];
}
}
} -
G.A.
aktív tag
Üdv!
8Bites mikróvezérlőhöz írogatok kódot, amit VS 2015-ben (C++) tesztelek.
A vezérlőre írt kódot C-ben írom, de a teszthez használt segédfunkciókhoz C++-t is használok.A probléma:
globális struktúra (pontosabban union) tömböt(pointert?) szeretnék funkcióval manipulálni (méret megadása, adatokkal feltöltés)Kódban kifejezve:
typedef union dns_answer
{
struct
{
my_16b name;
my_16b type;
my_16b rrs_class;
my_32b ttl;
my_16b rd_length;
my_32b data;
};
u8b b[16];
}dns_answer;
void function(u8b data[], dns_answer** answer)
{
dns_answer local_answer;
*dns_response = (dns_answer*)malloc(data[7] * sizeof(dns_answer));
for(u8b i = 0; i < data[7]; i++)
{
for (u8b x = 0; x < 4; x++)
{
local_answer.data.b[x] = data[x];
//*dns_response[i].data.b[x] = data[x];
}
*dns_response[i] = local_dns_resp; // HIBA ITT
}
}
dns_answer* answer_array = NULL;
u8b data[512] = {};
int main(void)
{
...
function(data, &answer_array);
...
}Ezzel a kóddal jelenleg az a problémám, hogy:
Ha érkezik egy adatcsomag(DNS üzenet), ahol több válasz van (data[7] > 1), akkor a jelölt helyen (HIBA ITT)
áll meg a kód... Hibaüzenet: Access violation writing location 0x00000000Ha jól értem olyan címre akar írni, ami nem létezik. A hiba eredetét a malloc()-ra tippelem. Következtetésem az, hogy ha kihagyom a function()-ban a malloc()-ot és az inicializáláskor az int main() előtt megadom a tömb méretet, akkor nincs ez a hiba.
Hogyan méretezhetném újra a struktúra tömbömet (dns_answer* answer_array) a funkción belül, úgy hogy az globálisan is megvalósuljon?illetve., hogy kerülhetném ki a function()-ban az átmeneti lokális struktúra használatát?
-
Domonkos
addikt
válasz
ZTE_luky
#5824
üzenetére
Najah - vannak itt gondok.
Egy csomo helyenintnek szeretnel pointert castolas vagy dereferalas nelkul ertekul adni. Ez nem szokott semmi jora vezetni. pl.:R7 = RC + R1 * 4;
Tovabba a printfekben a format stringek sem igazan korrektek a tipusokat nezve%d-vel ne akarj pointert kiirni... Azt hiszem hogy a:-ot is ki kellene escapelned - bar ez nem tuti.
Emellet van meg par dolog ami csak a frissebb szabvanyokkal megy el - bar nem tudom hogy neked melyiknek kell megfelelned.
Amit adtal korabban input file pelda most nem produkal semmi ertelmeset nalam
13 utan jobban raerek.
-
ZTE_luky
aktív tag
Köszönöm szépen a segítséget, hát igen no [] tömböm random meg van határozva, de annál kevesebb értéket is kivehet mint a max, többet nem. Nem tudom az mennyire lehet probléma. Jelenleg se történik semmi, valami ilyesmit kellett kihozni az egészből 14:00-kor kell leadnom, de nem működik, tele van warning-al és nem is csinál semmi értelmeset sajnos. PEdig a kiinduló C-file gyönyörűen működik. Nem tudom mi lehet a baj, eléggé belekeveredtem sajnos.
#include<stdio.h>
#include<string.h>
// ---------- Globale Variablen ----------
int no[] = {0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,
0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,
0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B};
// Address array
char string[9]; // String array
int R0; // (--int halt--) 0 Constant
int R1;
int R2; // (--int counter--) Index counter (String)
int R3; // (--int op--) Index Operation-Code
int R4; // (--int state--) Index strings
int R5; // (--int i--) Index counter (Address)
char R6; // (--char c--) Character to getchar
char R7; // (--char r1--) Register 1
char R8; // (--char r2--) Register 2
char R9; // (--char r3--) Register 3
int *RA; // (--int *no0--) BP of Address-array NEW
int *RB; // (--int *noi--) Flexibe Array Pointer NEW
char *RC; // (--char *string0--) BP of String-array NEW
char *RD; // (--char stringi--) Flexibe Array Pointer NEW
int RE; // SIZE 9
int RF; // FFFF
// ---------- Main Function ----------
int main()
{
R0 = 0;
R1 = 1;
R2 = 0;
R4 = 0;
R5 = 0;
RA = &no[0];
RC = &string[0];
RE = 9;
RF = 0xFFFF;
//no0 = &no[R0]; // Zero Element (in array "no") NEW
//string0 = &string[R0]; // Zero Element (in array "string") NEW
// ---------- Program ----------
L0: //init
R2 = R0; //counter
goto L1; //thestring;
L1: //thestring:
if (R2 < RE) // for (counter = 0; counter < 9 ;)
R6 = getchar(); //c
if ( R6 != EOF) //c
goto L2; //ignore;
else {goto L3;} //end
L2: //ignore:
if (R6 != 0x20 && R6 != 0xA) // R6=c
{
R2 += R1; //counter++;
//o++;
goto L1; //thestring;
}
// ---------- Search Function (Operating Code) ----------
// if (string[0] == 0x41 && string[1] == 0x44 && string[2] == 0x44)
if (*RC == 0x41 && *RC + R1 == 0x44 && *RC + R1 + R1 == 0x44) //NEW
{ //----- Function ADD -----
R3 = R1;
R4 += R1;
RB += R1;
R7 = RC + R1 * 4;
R8 = RC + R1 * 6;
R9 = RC + R1 * 8;
printf("%D:%d%c%c%c\n",RB,R3,R7,R8,R9); //Print the current string
}
//else if (string[0] == 0x53 && string[1] == 0x55 && string[2] == 0x42)
else if (*RC == 0x53 && *RC + R1 == 0x55 && *RC + R1 + R1 == 0x42)//NEW
{ //----- Function SUB -----
R3 = R1;
R4 += R1;
RB += R1;
R7 = RC + R1 * 4;
R8 = RC + R1 * 6;
R9 = RC + R1 * 8;
printf("%D:%d%c%c%c\n",RB,R3,R7,R8,R9); //Print the current string
}
//else if (string[0] == 0x41 && string[1] == 0x4E && string[2] == 0x44)
else if (*RC == 0x41 && *RC + R1 == 0x4E && *RC + R1 + R1 == 0x44) //NEW
{ //----- Function AND -----
R3 = R1;
R4 += R1;
RB += R1;
R7 = RC + R1 * 4;
R8 = RC + R1 * 6;
R9 = RC + R1 * 8;
printf("%D:%d%c%c%c\n",RB,R3,R7,R8,R9); //Print the current string
}
//else if (string[0] == 0x58 && string[1] == 0x4F && string[2] == 0x52)
else if (*RC == 0x58 && *RC + R1 == 0x4F && *RC + R1 + R1 == 0x52) //NEW
{ //----- Function XOR -----
R3 = R1;
R4 += R1;
RB += R1;
R7 = RC + R1 * 4;
R8 = RC + R1 * 6;
R9 = RC + R1 * 8;
printf("%D:%d%c%c%c\n",RB,R3,R7,R8,R9); //Print the current string
}
//else if (string[0] == 0x53 && string[1] == 0x48 && string[2] == 0x4C)
else if (*RC == 0x53 && *RC + R1 == 0x48 && *RC + R1 + R1 == 0x4C) //NEW
{ //----- Function SHL -----
R3 = R1;
R4 += R1;
RB += R1;
R7 = RC + R1 * 4;
R8 = RC + R1 * 6;
R9 = RC + R1 * 8;
printf("%D:%d%c%c%c\n",RB,R3,R7,R8,R9); //Print the current string
}
//else if (string[0] == 0x53 && string[1] == 0x48 && string[2] == 0x52)
else if (*RC == 0x53 && *RC + R1 == 0x48 && *RC + R1 + R1 == 0x52) //NEW
{ //----- Function SHR -----
R3 = R1;
R4 += R1;
RB += R1;
R7 = RC + R1 * 4;
R8 = RC + R1 * 6;
R9 = RC + R1 * 8;
printf("%D:%d%c%c%c\n",RB,R3,R7,R8,R9); //Print the current string
}
//else if (string[0] == 0x48 && string[1] == 0x4C && string[2] == 0x54)
else if (*RC == 0x48 && *RC + R1 == 0x4C && *RC + R1 + R1 == 0x54) //NEW
{ //----- Function HLT -----
R3 = R1;
R4 += R1;
RB += R1;
R7 = RC + R1 * 4;
R8 = RC + R1 * 6;
R9 = RC + R1 * 8;
printf("%D:%d%d%d%d\n",RB,R0,R0,R0,R0); //Print the current string
}
else printf("%04X\n", RF); //Print FFFF when it's an incorrct Value
goto L0; //init;
L3: //end
return 0;
} -
#5702
buherton
őstag
Neil Watts
#5701
buherton
őstag
válasz
Neil Watts
#5701
üzenetére
Szia!
Jó gondolat a karaktertömb és jó a probléma felvetés! Fél siker.
Egy struktúrát használnék pl.:
typedef struct
{
char isMinus;
unsigned int len;
char *number;
} number_sA fájlban ASCII-ként van letárolva, így amikor letárolnám a struktúrámba, akkor kivonnám az offsetet és egyszerű számként tárolnám, hogy később a műveletek során már ne kelljen ezzel foglalkozni.
A műveletek kicsit összetettebbek, de valóban a papíron való számolásra érdemes visszavezetni. Amiből kindulhatsz, hogy összeadásnál a leghosszabb szám hossza vagy plusz egy lesz az összeg hossza. Kivonásnál maximum a leghosszabb szám hossza.
Amit viszont ne kövess el, hogy konstans értékeket használsz! Ha ismerkedsz még csak a nyelvvel, akkor a prototípus lehet fix számú és akkor a logikát ki lehet próbálni, de utána illik generálissá tenni. Ehhez pedig melegen ajánlom a malloc/free függvényt. A struktúrában sem véletlenül van tömb pointer
. -
stepboy
csendes tag
válasz
dobragab
#5550
üzenetére
sziasztok,
Ezt a példát nem értem.
int temp = 1;
evil_api_function_call(fp, ptr, &temp);C99-ben tudod lokális változónak is képezni a "címét" egy trükkel. Pontosabban: tudsz compound literal segítségével temp tömböt létrehozni egy elemmel, ami viszont már konvertálódik pointerre.
Tehát azt akarod mondani, hogy lokális változó címét nem lehet paraméterként átadni függvényhíváskor?
-
maestro87
őstag
válasz
buherton
#5650
üzenetére
Ezt így nem fordítja le.
Szintaktikai hiba, nincs azonosító a deklarációban stb.
Pontosabban az én kódom így néz ki lefordítva erre a példára:header fájlban:
typedef struct
{
int date;
int month;
int year;
} date;
typedef struct
{
char ename[20];
int ssn;
float salary;
date doj[3];
} Employee;
Employee emp;A main függvénybe írva ezt, nem működik:
emp.date[]=
{
{,,},
{,,},
{,,}
};A pointer-est hogy gondoltad?
-
buherton
őstag
-
aviator
tag
válasz
dabadab
#5585
üzenetére
Nem akartam untatni a népet a teljes feladattal, illetve én is csak egy részét próbáltam megcsinálni első körben. Arról van szó, hogy van egy függvény, ami bekér három koordinátát, azaz csúcsonként hármat, tehát egy for ciklussal feltölti a csucsok tömböt 3x3 koordinátával, majd ezután visszaadja a haromszog típusú triangle struktúra címét. (Ezért kell, hogy pointer legyen a tömb típusa.) Ezt a címet veszi át egy másik függvény, ami elvégzi a lefoglalt terület felszabadítását. Eközben a főfüggvényben meg kell még oldani azt, hogy háromszög struktúrából (háromszögekből) is többet lehessen bevinni, méghozzá előre nem meghatározott darabot (dinamikus tömb).
A magyarázatod egyszerűsíthető úgy, hogy azért szállt el a program mert a tömb tele volt null pointerekkel, illetve a hiba a foglalással azért oldódott meg, mert a foglalás után a pointereknek már lett értékük? Tehát inicializálatlan pointerekkel nem dolgozunk?
-
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)); -
aviator
tag
Tisztelt Szakértő Urak!
Újabb kérdésem lenne:
typedef struct koordinata
{
int x;
int y;
int z;
}koordinata;
typedef struct haromszog
{
koordinata* csucsok[3];
}haromszog;Tehát létre lett hozva egy koordináta struktúra három int mezővel, illetve egy háromszög struktúra egy háromelemű pointertömbbel: A háromszög struktúra egy 3D-s háromszöget tárol amelynek három csúcsa van, egy csúcsnak pedig három koordinátája. Azért lett pointer a tömb típusa mert később a koordináták címeire lesz szükség.
A továbbiakban egy egyszerű koordinátabekérést szeretnék csinálni a 0 indexű csúcsra a következő módon:
haromszog triangle; //struktúra típusú változó létrehozása
scanf("%d %d %d", &(triangle.csucsok[0]->x),&(triangle.csucsok[0]->y),&(triangle.csucsok[0]->z))Nem árulok el szerintem nektek újdonságot: ez így nem működik. Lefut, a fordító jónak látja de nem működik. Ti már biztos tudjátok az okát én még nem, viszont a megoldást igen:
haromszog* triangle=(haromszog*)malloc(sizeof(haromszog));
triangle->csucsok[0]=(koordinata*)malloc(sizeof(koordinata));
scanf("%d %d %d", &(triangle->csucsok[0]->x),&(triangle->csucsok[0]->y),&(triangle->csucsok[0]->z))Amit nem értek: miért nem működik lefoglalás nélkül? Miért kell a csúcsoknak is külön helyet foglalni? Azt hiszem sajnos ez már az a szint amikor nagyon összefüggéseiben kéne látnom a dolgokat, úgy tűnik ezzel hadilábon állok.
A válaszokat előre is köszönöm, aki esetleg érez némi motivációt arra, hogy egy kicsit részletesebben elmesélje ezt nekem, felépítve egy gondolatmenetet ami alapján érthetőbbé válik, hogy mi miért van, mi miből következik azzal sokat segítene...akár privátban is, hogy ne terheljük másoknak triviális dolgokkal a fórumot.
-
-
Jester01
veterán
válasz
dobragab
#5575
üzenetére
a címét nem képezhetjük, hiszen ahhoz először pointerré konvertálódik,
Szerinted. A szabvány szerint meg de. Idéztem ott feljebb kicsivel:
Except when it is the operand of the sizeof operator or the unary & operator
Tehát ha & operátort alkalmazol a tömbre akkor nem konvertálódik pointerré.
-
dobragab
addikt
válasz
jattila48
#5574
üzenetére
Jól mondod.
Az egyszerűség kedvéért úgy is lehet definiálni, hogy a tömbön mint típuson két művelet értelmezett:
- sizeof
- automatikus konverzió, ami a tömb első elemére mutató pointerré konvertáljaEbből minden más, tömbökre jellemző tulajdonság levezethető:
- indexelni is "csak" a pointert tudjuk, az indexelés meg ugye ekvivalens egy címszámítással és egy dereferálással
- a tomb + 5 kifejezés nem azt jelenti, hogy a tömbhöz adunk ötöt, hanem az elejére mutató pointerhez, azaz a tömb ötödik elemére mutató pointert jelenti
- *tomb egy dereferálás, mégpedig a tömb első elemét jelenti
- a címét nem képezhetjük, hiszen ahhoz először pointerré konvertálódik, az így keletkezett temporális objektumnak nem képezhető a címe
- tömbnek nem adhatunk értéket, hiszen a konverzió eredménye temporális objektum, ami C-ben nem balérték
- függvényparaméterként csak úgy adhatjuk át, hogy előtte pointerré konvertálódik
- ha struktúrába rakod, a neki lefoglalt hely természetesen sizeof(tomb) lesz -
jattila48
aktív tag
válasz
Jester01
#5573
üzenetére
"A tömb pedig ekvivalens a pointerrel"
Na na! Csak óvatosan! Pointernek adhatsz értéket, tömbnek nem. Ez egy igen lényeges különbség. A tömb, mint cím, fordítás idejű konstans, míg a pointer egy változó, ami futás időben kap értéket. Pointernek veheted a címét (hiszen változó), tömbnek pedig nem (mármint char array[10]; char **p=&array; utasításoknak nincs értelme, míg char *p; char **pp=&p; -nek pedig van). Az, hogy a C-ben és C++ -ban szemantikailag nincs eléggé megkülönböztetve a pointer és a tömb, az a nyelv egyik hiányossága, amellett, hogy nagyfokú rugalmasságot is biztosít.
C++ -ban például teljesen helyénvaló származtatott osztály pointert (D *) publikus ősosztály pointerként (B *) használni, míg D ** pointer B ** pointerként való használata tiltott, nyilvánvaló okok miatt. Ugyanakkor nyugodtan meg lehetne engedni D *[] típusú változó B *[]-ként való használatát, azonban ezt mégsem lehet, mivel nincs eléggé megkülönböztetve a pointer és a tömb. -
Jester01
veterán
válasz
aviator
#5570
üzenetére
Ez meg a híres tömb-pointer ekvivalencia. C-ben a tömb automatikusan konvertálódik az első elemére mutató pointerré:
Except when it is the operand of the sizeof operator or the unary & operator, or is a string literal used to initialize an array, an expression that has type "array of type" is converted to an expression with type "pointer to type" that points to the initial element of the array object and is not an lvalue.
-
aviator
tag
válasz
aviator
#5569
üzenetére
char szoveg[101];
char*szpt;
scanf("%s",szoveg);
szpt=(char*)malloc(sizeof(char)*((strlen(szoveg))+1));
strcpy(szpt,szoveg);
printf("%s",szpt);
free(szpt);Újabb hasonló probléma. A strcpy itt elméletileg egy char típusú tömböt másol egy char* típusú tömbbe, ami nem lenne lehetséges. Sejtem, hogy az előző "indexelés megeszi a pointert" dolognak lesz itt is jelentősége, gondolom itt az indexelés a string-ben áll annak ellenére, hogy nem látszik az indexelő [] operátor. Kiíratáskor pedig látszólag string-ként íródik ki a pointer típus.
Amit nem értek az az, hogy a strcpy két paramétere hogy lesz azonos típusú, melyiknek változik meg a típusa (ha egyáltalán megváltozik) és miért, illetve, hogy a kiíratáskor hogy lesz a pointerből kiíratható string. -
aviator
tag
typedef struct koordinata
{
int x;
int y;
int z;
} koordinata;
void beolvas(koordinata* pont)
{
scanf("%d %d %d",&(pont->x),&(pont->y),&(pont->z));
}
int main()
{
int a,i;
printf("Kerem a koordinatak szamat");
scanf("%d",&a);
koordinata* koord = (koordinata*) malloc(sizeof(koordinata)*a);
for(i=0;i<a;i++)
{
beolvas(&koord[i]);
}
for(i=0;i<a;i++)
{
printf("(%d;%d;%d)",koord[i].x,koord[i].y,koord[i].z);
}
free(koord);
return 0;
}Üdv!
A feladat itt az volt, hogy függvénnyel töltsek fel egy koordinátákat tároló struktúrát ahol a struktúrák egy dinamikus tömb elemei. A feladatot sikerült megoldani, a kód így működőképes, egy dolgot viszont nagyon nem értek: A nyíl operátort ha jól tudom akkor használjuk, ha pointeren keresztül akarjuk elérni egy struktúra mezőit. Ha pointer nélkül hivatkozunk akkor a pont operátort használjuk. Ha ez így van, akkor miért van az, hogy a függvény definíciójában a pointer típusú, pont nevű paraméteren keresztül nyíllal hivatkozok a mezőkre, alul a kiíratásnál pedig már ponttal, annak ellenére, hogy a koord változó még mindig koordináta típusú pointer?
-
dobragab
addikt
Igen, ugyanarról beszéltek. Futásidőben már nem tudható a pointer típusa, de fordítási időben baromi fontos. Onnan tudja a fordító, hogy pointer aritmetika / tömbindexelés esetén hány bájt offset-je van a következő elemnek.
int * a = tomb;
int * b = a + 1; // 4 bájttal tolta arrébb
char * c = "text";
char * d = c + 1; // 1 bájttal tolta arrébbFeltéve, hogy az int 4 bájtos.
-
zka67
őstag
válasz
Jester01
#5552
üzenetére
Szia,
Ezzel együtt az eredeti kiindulás az volt, hogy az & operátor nem egy számot ad vissza, hanem egy megfelelő típusú pointert. Emiatt aztán (int)&x + 1 és (int)(&x + 1) az nem ugyanaz (kivéve ha véletlenül x mérete 1 byte)
Mint említettem, fizikailag a pointer egy (memória)címet tartalmaz, ami egy egyszerű szám (ez lehet 16, 32 vagy akár 64 bites érték is, rendszertől függően, de ebbe most ne menjünk bele). A pointer típusát a fordító kezeli, magából a pointer értékéből ez nem derül ki, mivel nem tárolja azt.
Az eredeti kérdés az az volt, hogy a pointer elé miért nem kell a & jel, ezt próbáltam meg konyhanyelven elmagyarázni a kérdezőnek, hogy megértse.
int main(int argc, char* argv[])
{
char c;
char *p;
p = &c;
printf("sizeof(c)=%d, sizeof(p)=%d, p=%08X\r\n", sizeof(c), sizeof(p), p);
return 0;
}Ennek az eredménye az alábbi:
sizeof(c)=1, sizeof(p)=4, p=0018FF53azaz a c változó a 0x0018FF53-as memóriacímen található. Nincs a p változóban semmilyen típus, csak a változó címe.
-
Jester01
veterán
memóriacímet tárolnak, ami egy darab szám
Ez persze nem igaz, a pointerek belső szerkezete implementációs kérdés. Például szegmentált memóriamodellben van ugye far pointer is, amiben 2 szám is van, vagy harvard architektúrán a szám mellé még azt is tudni kell adat vagy program memória stb.
Nyilván ha akarom akkor ez 1 szám mivel csak egy halom bit azt meg bármikor felírhatom számként
Az is igaz, hogy a hétköznapi rendszerekben valóban elég egy szám.Ezzel együtt az eredeti kiindulás az volt, hogy az & operátor nem egy számot ad vissza, hanem egy megfelelő típusú pointert. Emiatt aztán (int)&x + 1 és (int)(&x + 1) az nem ugyanaz (kivéve ha véletlenül x mérete 1 byte)
-
dobragab
addikt
válasz
dabadab
#5549
üzenetére
Igen.
Kicsit off, de hátha segít valakinek, ezért inkább leírom, ha már eszembe jutott.
int temp = 1;
evil_api_function_call(fp, ptr, &temp);C99-ben tudod lokális változónak is képezni a "címét" egy trükkel. Pontosabban: tudsz compound literal segítségével temp tömböt létrehozni egy elemmel, ami viszont már konvertálódik pointerre.
evil_api_function_call(fp, ptr, (int[]){1});
-
É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 -
zka67
őstag
válasz
ToMmY_hun
#5547
üzenetére
Szia, de igen, a pointerek csak és kizárólag egy darab memóriacímet tárolnak, ami egy darab szám. Az összes többit a fordító végzi el. Ha te pl. egy int típusú tömb címét adod át paraméterként egy függvénynek, az átadott paraméter csak a tömb címét tartalmazza. Amikor a függvényben a tömb következő elemére lépsz, a fordító által generált kód szerint lesz 4-el nagyobb a címed. Ha karakter tömb címét adod át, a fordító csak 1-el fogja növelni a címet. Ennél egyszerűbben nem tudom megfogalmazni.
-
ToMmY_hun
senior tag
válasz
Jester01
#5546
üzenetére
Erre kérhetek valamilyen irodalomból származó referenciát? Amiket én néztem azokban sehol sem említik, hogy bármi egyebet csinálna a memóriacím visszaadásán kívül. Maga a létrehozott pointer nyilván nem csak egy számot tárol, azzal nem lehetne leírni egy struktúra belső szerkezetét.
-
Jester01
veterán
válasz
ToMmY_hun
#5545
üzenetére
Pedig éppenséggel pointer készítő, mivel nem csak egy számot (a címet) adja vissza hanem konkrétan egy megfelelő típusú pointert (aminek a belső reprezentációja lehet, hogy nem is csak egy szám). Arra a valamire mutató pointert gyárt neked amit operandusként megadtál. (Igen, tudom, hogy amúgy address operator a neve.)
"The result is a pointer to the object or function designated by its operand"
-
-
-
aviator
tag
Sziasztok!
Valaki el tudja nekem magyarázni, hogy dinamikus tömbök esetén miután malloc-cal lefoglaltam a helyet az elemeknek és olvasom be őket scanf-fel, miért kell a változó neve elé & jel?
Most tanulom ezt a témakört, szóval lehet hülye kérdés volt, de azért nem értem, mert ha nem tömbről van szó, hanem csak egy sima pointernek adom értékül a malloc által lefoglalt helyet (x=malloc(sizeof(int))), akkor a scanf-ben nem kell az & jel (scanf("%d",x)), mivel már megvan, hogy hova fog kerülni a beolvasott érték.
Köszönöm, ha valaki segít.
-
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.
-
"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.
-
EQMontoya
veterán
válasz
bandi0000
#5368
üzenetére
Az a probléma, hogy amit csinálni akarsz, az shallow copy, de Neked deep copyra lenne szükséged. Most a shallow copyt is viszonylag rosszul csinálod, mert a pointered heapen van, a lokális változód pedig valszeg stacken, tehát ez így ebben a formában nem fog menni.
A megoldást az strcpy (deprecated!) illetve strncpy függvények környékén keresd.
-
EQMontoya
veterán
Mert amit átadsz, az nem az egész tömb. Gondolj csak bele, durva is lenne, ha az egész tömböt mindegy egyes hívásnál lemásolnád. Elég költséges lenne a rekurziód.
Amit átadsz, az egy pointer (memóriacím), a tömb kezdetére.Amit leírtál, az ezzel ekvivalens: void rekurzivfv(int* m)
-
Zsolt1
tag
Sziasztok!
Egy olyan kérdésem lenne, hogy egy rekurzív függvény hívásnál, ahol a függvény paramétere egy tömb, ott miért módosul az eredeti tömb a rekurzióból visszatérés után? Elvileg úgy lenne logikus, hogy mivel azt a tömböt csak paraméterként átadom a függvénynek rekurzív hívásnál és az ott abban a fv-ben az újonnan létrehozok egy tömböt, akkor csak odafelé adom át az értékeket, visszafele nincs módosítás, és miután lefutott a rekurzív fv., akkor a felső szinten nem változik meg a tömb tartalma. Azért nem értem a dolgot, mert pont e-miatt kell ugye változó helyett pointert használnom, ha meg akarom tartani az értéket a rekurzióból visszatérés után is.
Ez most szerintem kicsit össze-vissza lett ezért írok inkább egy példát, hogy mire gondoltam:
void rekurzivfv(int tomb[][M]) { //definiálom a fv-t és megadom paraméternek a tömböt
...függvényen belüli műveletek amik módosítják a tömb tartalmát....
rekurzivfv(tomb); //meghívom a fv-t, ami megkapja a tömböt
...itt már a tömb elemeinek értéke módosult, ahhoz képest, ami a függvény elején volt, arra
amire a rekurzió alatt változott pedig elvileg nem szabadna, mert a rekurzív fv-nél a fv újra
létrehozza a tömböt és miután a végigfutott, az innen már nem lehetne elérhető, mert
semmilyen formában nem adtam vissza...
}
Az jutott az eszembe még, hogy a teljes tömb átadásakor ott igazából tömb elejére mutató címet adom csak át (ha jól tudom), szóval olyan mintha az egy pointer lenne elvileg. Lehet, hogy az miatt módosul?
Meg lehet valahogy azt oldani, hogy ne módosuljon a rekurzív meghívás alatt az alap függvényben a tömb? Előre is köszönöm a segítséget! -
Karma
félisten
válasz
#36268800
#5279
üzenetére
Nem a double-int konverzióval van baj, sokkal nagyobb probléma, hogy a 34. és a 43. sorban a számítás végző függvényeket (pointerként) adod be a printf-nek, nem pedig meghívod őket.
A double kockázat megoldása annyi, hogy a 7. és a 14. sorban a hányadost 2-ről 2.0-ra átírod.
-
#5142
EQMontoya
veterán
DrojDtroll
#5141
EQMontoya
veterán
válasz
DrojDtroll
#5141
üzenetére
FILE **fin;
vs.
fin=fopen("pakol.be", "r+");Túltoltad kicsit a csillagot.
A változókat típus szerint érdemesebb lenne külön sorba deklarálni, ez így nagyon takony.
Szerk:
int** ladak
vs.
for(i=0;i<ladak_szama;i++){
if(ladak(i)>max && ladak(i)!=jel){
max=ladak(i);
maxindex=i;
}
}Itt is egydimenziósként használod a **-ot.
Szerintem némileg fogalmi zavarban vagy a pointerekkel, azt érdemes lenne tisztázni, mielőtt nekiállsz őket így használni.
-
Az indexelest nem vettem eszre, akkor a nem lefoglalt memoriateruletrol gondolom behalaszott valamit.
Pointereket leszedtem, atirtam azokat, amiket emlitettel, de meg igy se irja ki, ha nem lehet osszerakni az oldalakbol haromszoget.Azt is feldobta csoporttarsam, hogy hasznaljam az stdbool.h libet, de azzal nemhiszem ,hogy elorebb lennek, nem valtoztatna rajta.
-
válasz
Pttypang
#5112
üzenetére
Erre is jo, de alapvetoen ez nagyon szuk resze a pointerek felhasznalasi modjanak. Azt gondold vegig, hogy imperativ programozasi nyelvekben (pl. C) megkulonboztetunk ket dolgot:
- ertek
- identitasTehat ha van ket valtozonk:
int a = 5;
int b = 5;.. akkor az ertekuk megegyezik, az identitasuk nem. A pointer arra jo, hogy ne erteket kezelj, hanem identitast. Ha atadom egy fuggvenynek a 'b' valtozo erteket, akkor az 5-ost adom at. Az eredeti b-vel (az identitassal) nem tud a hivott fuggveny semmit sem kezdeni, hiszen arrol nem tud, o csak az erteket (5) latja. Ha a b-re mutato pointert adom at (&b), akkor a hivott fuggveny az identitasrol tud, meg tudja valtoztatni b erteket, ha akarja.
Kepzelj el pl. egy fuggvenyt, ami kicsereli ket valtozo erteket. Ezt nem lehet megcsinalni csak ertekek atadasaval -- a 'csere' fuggveny bemenete ket _identitas_, hiszen ertekeket nem lehet megcserelni, azok ugyanugy ertekek maradnanak.
Funkcionalis nyelvekben (pl. Lisp, ML-leszarmazottak) nincs szukseg ilyesmire, mert ott csak ertekek vannak, identitas nincs. (Illetve van, csak sokkal jobban kezbentartott modon kezeljuk.)
-
válasz
Pttypang
#5110
üzenetére
Vegulis ezen kivul nincs tul sok dolog. Par aprosag:
- az operatorok probalnak okosak lenni, ezert ha pl. inkrementalsz egy pointert (ami ugye egy sima elojel nelkuli egesz szam) akkor az nem feltetlen egyet ugrik, hanem annyit, amekkora annak a tipusnak a merete, amire mutat. Tehat pl. egy 64 bites double-ra mutato pointer egy 32 bites architekturan 8 bajttal novekszik, ha inkrementalod.
double ertek = 5;
double * a = &ertek;
printf("%p\n", a);
a++;
printf("%p", a);>> 09FFB28
>> 09FFB30
Ketto kulonbsege: 8- a tomb az nem mas, mint a tomb kezdetere mutato pointer
.. most jo lenne, ha konkret dolgokat kerdeznel
-
válasz
Pttypang
#5105
üzenetére
Van a neten csomofele leiras, erdemes rakeresni, de probaljuk meg itt is.
Ugyebar C-ben (es mas imperativ prog. nyelvekben is) vannak valtozoink, vagy nevezzuk oket inkabb ertekeknek, mert az tokmindegy, hogy valtoznak-e vagy sem. A forditonak megprobaljuk megmondani, hogy milyen tipusu az az ertek, amit letrehozunk. (A tovabbiakban tegyuk fel, hogy sima 32 bites arhichitekturan vagyunk). Pl.:
double a = 1;
Egy valtozorol mindig ket dolgot tudunk: mekkora helyen fer el (hany bitnyi hosszu), es hogyan ertelmezzuk. Azt, hogy hogyan/minek ertelmezzuk, szoktak tipusnak is nevezni.
Most 'a'-rol a kovetkezoket tudjuk:
- 64 bitnyi informacionk van
- ezt egy elojellel rendelkezo lebegopontos szamkent ertelmezzukHa van egy ilyenunk:
double * a;
.. akkor errol az tudjuk, hogy
- 32 bitnyi informacionk van
- ez egy egesz szam, es ugy ertelmezzuk, mint egy memoriacimet. A memoriacimen pedig egy 64 bit hosszu lebegopontos szamot talalunk.Tehat a pointer egy jellemzoen 32 vagy 64 bitnyi informaciot tartalmazo szam. A memoria szepen be van szamozva 0-tol 2^32 vagy 2^64-ig. Ha ahhoz a memoriarekeszhez mesz, aminek a szama megegyezik a pointer ertekevel, akkor ott egy olyan erteket talalsz, aminek a tipusa a pointer tipusaban jelezve is van.
A pointert a * jelzi altalaban. Ha van pl. egy
double ** a;akkor az a kovetkezo jelenti, analog modon:
- van egy 32 bites ertekunk
- ez egy egesz szam, es ugy ertelmezzuk, mint egy memoriacimet. A memoriacimen pedig egy 32 bit hosszu egesz szamot talalunk, amit ugy ertelmezunk, mint egy 32 bites erteket, amit ugy ertelmezzunk, mint egy memoriacimet. A memoriacimen pedig egy 64 bit hosszu lebegopontos szamot talalunk.Ez idaig vilagos?
(Tobbieknek: szandekosan vagyok pontatlan az int, double, etc. meretevel kapcsolatban.)
-
Igen, az angollal elevickelek.
Ott tartok, hogy az eloadas folian le van irva, hogy mi is ez pontosan, de ezzel nem igazan vagyok elorebb, mert nem ertem, hogy miert jo ez. Marmint mire hasznalhato, meg pontosan hogyan.. Szoval a gyakorlati alkalmazasat valamiert nem latom at.
A pointereken kivul a tombok fuggvenyeknek parameterkent valo atadasa sincs meg, de szerintem erre megoldast talalok majd valamelyik eloadas folian.
A strukturakkal egyelore meg nem foglalkoztam, eloszor ezeket szeretnem megerteni, megtanulni a hasznalatukat normalisan.
-
buherton
őstag
válasz
CPT.Pirk
#5100
üzenetére
Hóhó ez nagyon spéci cucc. Akkumulátor töltő vagy mi lesz belőle?
Most nekem is lenne egy kérdés. Nem igazán C viszont ha már felmerült az ARM, akkor megkérdezem.
Context switcher-t írok, de van két probléma, amivel nem tudok dűlőre jutni:
1. PendSV-ben történik a váltás, ahol értelemszerűen az MSP-t használom. Igen ám, de a stack pointer minden egyes meghíváskor 0x20-val csökken az értéke. Miért csinálja ezt?2. Így térek vissza a PendSV-ből:
volatile uint32_t LR_reg;
LR_reg = 0xFFFFFFFD;
__asm volatile ("BX %0" : "=r" (LR_reg));
Ennek ellnére még mindig privileged módban fut a cucc. Ha ez előtt beállítom direktbe a CONTROL regisztert, akkor user-ben fog futni, de nem erre találták ki az EXEC_RETURN-t? -
Zsolt1
tag
Sziasztok!
Egy kis segítséget szeretnék kérni kétdimenziós tömb átadása függvénynek témakörben. Gyakorlaton sajnos csak 1 dimenziós tömbbel csináltuk és sajnos úgy nem működik.Az egydimenziósnál:
void beolv(int*); //main() fv. előtt
beolv(tomb); //main() fv.-ben: tömb átadása a beolv fv.-nek
void beolv(int *t) {... //main() fv. utáni kifejtésA kétdimenziósnál (ami nem működik):
void ujadat(int*,char*,char*); //három tömböt adok majd át neki, 1 db egydimenziósat és 2 db kétdimenziósat
ujadat(azontomb,tipus,rendszam);
void ujadat(int *tomb, char *chartomb1, char *chartomb2) {...A codeblocks eltérő típusú pointerekre panaszkodik és gondolom is, hogy miért, mert kétdim. tömbnél a tomb és a tomb[] nem ugyan arra a címre mutat csak nem tudom, hogy hogy kéne megoldani azt, hogy az összesnél jó legyen az átadás.
Találtam egy ilyet: [link] és egy ilyet is:[link] ezek alapján így néz ki a kétdimenziósnál a 3. sor:
void ujadat(int *tomb, char chartomb1[][HOSSZ], char chartomb2[][HOSSZ2]) {...
Ezzel már sokkal kevesebb hibát dob a CB, de még így is eltérő típusú pointereket ír.Ha valaki tudna benne segíteni azt nagyon megköszönném, mert elég sok helyen megnéztem már és szinte sehol sem írnak ezzel kapcsolatban semmit, illetve ha írnak is, akkor sem működik.
-
buherton
őstag
1.
Ezt ne is próbáld megfejteni, mert unspecified az inkrement és dekrement kiértékelési sorrendje ilyen esetekben.2.
Nem szükséges az L, mert a fordító castolni fogja, de ajánlott, mert így szép.3.
Ilyenekkel ki lehet kergetni a világból . Az elmúlt 4 évben egészen biztosan nem írtam le még gondolatban sem a scanf-t .4.
Nincs különbség. Az utóbbit ajánlatos használni, mert nem típus, hanem a változó lehet pointer.5.
Lehet, mert az enum egy számot reprezentál, viszont nem ajánlatos íly módon használni, mert nagyon megtudja keverni az embert.+1.
Erre van egy uppercase vagy milyen standard függvény. -
Hani
aktív tag
Uraim!
El vagyok keseredve.
Jó 10 év után újra elővettem a C-t, gyorsan átfutottam pár nap alatt az egészet és arra kellett rájönnöm, hogy valahol elhagytam az agyam, mert akkoriban még egész jól ment, most meg alapvető dolgokat nem értek. Persze az is lehet, hogy mindig is hülye voltam, csak akkoriban nem jöttek elő ezek a kérdések... nem tudom, mindenesetre segítséget kérek, mert magamtól nem megy és a google sem a barátom ezekben (és még egy rakás másban sem, de most ezek jutottak hirtelen eszembe):1. Van egy olyanom, hogy
int a = 1, b = 1, d = 1;
printf("%d, %d, %d", ++a + ++a + a++, a++ + ++b, ++d + d++ + a++);
Kérdés, hogy mit ír ki? A megoldás: 15, 4, 5. De miért?
2. Legyen egy long int-em:
long int li = 12345L;
Miért kell nekem az 12345 végére az L betű? A fordítónak jelzem, ha nem lenne elég, hogy odaírom, hogy long? Saját magamnak jelzem, nehogy elfelejtsem a típust? Egyéb?3. scanf és az ő filterezése.
Elvileg lehet olyat, hogy scanf("%[0-9a-fA-F]", &akarmi), hogy csak számokat és a-f / A-F karaktereket olvashasson be. Nekem mégsem megy, sem a komplementer változata ^0-9... verzióban. Mit rontok el?4. Pointeres változók.
Miben különbözik az int* i és az int *i ? Van egyáltalán bármi? Mondjuk ezt közben pont megtaláltam, miközben írtam, úgyhogy sztornó (a válasz itt)5. enum-ok.
Legyen két felsorolásom:
enum birds {SPARROW, PEACOCK=5, PARROT};
enum animals {TIGER = 8, LION, RABBIT, ZEBRA};enum birds m;
m = LION; //Ezt elvileg nem lehetne, de mégis lehet. Miért?
Szóval én eddig azt hittem, hogy ha van egy enum típusú változóm, akkor azokat az értékeket adhatom neki, amik a felsorolásban szerepelnek, de úgy tűnik, mégsem. Valahol elvesztettem a fonalat.+1. Nagybetűsíteni szeretnék egy stringet egy függvénnyel: megkapni paraméterben és visszaadni a nagybetűs verzióját. Erre több megoldás is lenne, de valahogy egyik sem az igazi:
- valamiért nem viszi a sima strupr()-t, ráadásul az az eredeti változót változtatja meg, ami nem oké. Csinálnék helyette egy másikat, de vagy kell hozzá globális változó, vagy nem ideális a memóriafelhasználás, vagy megváltoztatja az is az eredeti paramétert... Hogy kéne ezt normálisan?
Amikkel próbálkoztam, azok ezek:void upper_string(char *string)
//Ez már megy, de ez is megváltoztatja az eredeti paramétert, ugye.
{
while(*string)
{
if ( *string >= 'a' && *string <= 'z' )
*string = *string - 32;
string++;
}
}Lehetne olyan, hogy:
char* upper_string2(const char *string)
{
int i=0;/*
Namármost. Vagy definiálok egy globális char copystr[]=""; változót és annak a címét használom,
vagy definiálunk itt egy olyat, hogy char copystr[(strlen(string)]=""; , ami viszont lokális változó,
és nem jó ötlet lokális változó címét visszaadni a függvényen kívülre; vagy csinálunk egy static változót
itt helyben, aminek viszont méretet kell adni, amit nem lehet csak úgy strlen-nel. Én ezt az utóbbit választom, mondjuk 255-ös hosszal, de hát ez is milyen már.
*/static char copystr[255]; //Lehetne ez [65535] is akár.
strcpy(copystr, string);while(string [ i]!='\0')
{
//Csak a kisbetuket valtoztatjuk, a tobbi marad
if ( string(i) >= 'a' && string(i) <= 'z' )
copystr(i) = string(i)-32;
i++;
}
return copystr;
}Vagy lehetne simán ez is, de ez is megváltoztatja az eredeti változómat:
char* upper_string3(char str[])
{
int i=0;while(str(i) !='\0')
{
if ( str(i) >= 'a' && str(i) <= 'z' )
str(i) = str(i)-32;
i++;
}
return str;
}Szóval van baj, nem tudom, hogy mikorra állnak vissza a fejemben a dolgok, de elkelne egy kis segítség.
-
axioma
veterán
válasz
buherton
#4816
üzenetére
C-t akarsz tesztelni vagy algoritmust csak C-ben megvalositva?
(Ami kiguglizhato, az nem azert nem jo kerdes szigoruan szvsz, mert azt munka kozben is kiguglizza es hasznalja. Amit viszont o kell megalkosson... azt eleve tudnia kell.) Persze ha kodolas kell es nem az alkoto munka, akkor mind1.
Multkor egy konyvet neztem amit valaki ajanlott (de mikor mar elvi hibat is vetett a "megoldasban", nem csak elirast meg felesleges, de a megoldast nem zavaro koroket, akkor felreraktam), ott volt egy rakat linkelt listas feladat, ami pointeres, meg az adatszerkezetet is kitalalhatja hozza. Ilyen volt pl. hogy "korrupt" linkelt listaban (az utolso elem valami koztes elemre mutat) keresd meg konstans tarhely es ordo(N) muveletigennyel az elso ismetlodo elemet. De ehhez mar a trukkot kell ismerni (ordo(N^2) vagy felesleges bit per elem megengedesevel persze nem is nehez). -
buherton
őstag
Valaki tud igazán durva C tesztet? Aminél még egy tapasztalt programozónak is vakarnia kell a fejét. Az a baj, hogy a neten találtam párat, de azok nem elég kemények. Lehetőleg ne a printf, fopen, fseek és társaira feküjdön rá, mert azt úgy sem használom, hanem a deklarálás, definiálás, inicializálás, pointerek legyenek lehetőleg.
-
tototos
addikt
válasz
kmisi99
#4786
üzenetére
hát itt van elég sok gond.
Ha egy függvény mutatót kér paraméternek akkor hiába írod oda, hogy double* még nem fogja átadni a változó címét.
Másrészt dekralálsz változókat a main-ben min és max néven. Majd ezeknek a címét akarod átadni a függvénynek, a függvényen belül meg ezeket a címeket akarod átírni a tömb elemeinek címére?
Döntsd el, hogy a maxot és mint szeretnéd külön tárolni, vagy elég ha a tömb bizonyos elemeire mutatnak a pointerek. -
Karma
félisten
válasz
alapz@j
#4708
üzenetére
Szerintem az lenne a pláne, ha lenne const char *-os konstruktor (ez heapre másol) és egy char *-os ami átveszi a tulajdonjogot a stringről, és döntse el a kóder hogy melyik releváns.
De egyébként mi az C-ben, hogy konstruktor?
Ha tényleg C-ről van szó, akkor semmi se gátol meg abban, hogy a függvények neve is tükrözze hogy mit csinál a pointerrel. -
alapz@j
tag
válasz
don_peter
#4560
üzenetére
A "Valaminev#60#120#185#225#240#260" -ből egy ciklussal a kettőskereszteket nullára cseréled:
Valaminev\060\0120\0185\0225\0240\0260
így létrejön 7 stringed. A char memtomb[7][46] helyett egy pointer tömböt csinálsz (char *memtomb[7]) és menet közben mindig feljegyzed az aktuális stringedre mutató pointert:
unsigned char meminput[] = "Valaminev#60#120#185#225#240#260";
unsigned char *memtomb[7];
memtomb[0] = meminput;
size_t len = strlen(meminput);
int memptr = 1;
for (int i = 0; i < len; ++i) {
if (meminput[i] == '#') {
meminput[i] = 0;
memtomb[memptr++] = meminput + i + 1;
}
}
for (int i = 0; i < 7; ++i)
printf("%s\n", memtomb[i]); -
alapz@j
tag
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Pluralsight-on csinálom a C képzéseket, pont azt monta az oktató ennél a résznél, hogy ez a legegyszerűbb módja mert egyszerű utána felszabadítani a memóriát, és ugyan úgy lehet hivatkozni egy elemet, ahogy statikus 2D tömbnél. Neten- YT-n mindenhol a for ciklussal feltöltögetős verziót láttam, azért örültem meg ennek, de hát nem megy.
nagy fába vágtam a fejszém
.
Ha tényleg C-ről van szó, akkor semmi se gátol meg abban, hogy a függvények neve is tükrözze hogy mit csinál a pointerrel.
Új hozzászólás Aktív témák
● olvasd el a téma összefoglalót!
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- iPhone topik
- Milyen asztali (teljes vagy fél-) gépet vegyek?
- Októberben kerülnek legacy státuszba a régebbi GeForce VGA-k
- CES 2025: Megjött az Amazfit Active 2
- vrob: Az utolsó DOS játékok 1996 - 1997-ben, egy korszak lezárul
- Proxmox VE
- Milyen billentyűzetet vegyek?
- Formula-1
- Kerékpárosok, bringások ide!
- LG LCD és LED TV-k
- További aktív témák...
- Dell 3280 Intel core i3 10100T 8gb ddr4 3,0Ghz 250ssd aio all in one pc
- DELL XPS 9550
- i5 3570 / 24GB DDR3 / 240GB SSD / GTX 1650/ WIFI, takarítva, pasztázva, telepítve / HP Compaq 8300
- iPhone 8 Rose gold
- HP ProBook 650 G4, 15,6" FHD IPS , I7-8650U CPU, 8GB DDR4, 256GB SSD, LTE, W11, Számla, 1 év garanci
- 129 - Lenovo Legion Pro 7 (16ARX8H) - AMD Ryzen 9 7945HX, RTX 4080
- GYÖNYÖRŰ iPhone 13 Pro Max 128GB Graphite -1 ÉV GARANCIA - Kártyafüggetlen, MS3063
- BESZÁMÍTÁS! LG UltraGear 27GL850-B 144Hz QHD 1ms monitor garanciával hibátlan működéssel
- Telefon felvásárlás!! Samsung Galaxy A12/Samsung Galaxy A22/Samsung Galaxy A32/Samsung Galaxy A52
- Bomba ár! HP EliteBook 840 G5 - i5-8G I 8GB I 128GB SSD I 14" FHD I HDMI I Cam I W11 I Gari!
Állásajánlatok
Cég: FOTC
Város: Budapest