Új hozzászólás Aktív témák
-
Lortech
addikt
A szóköz arra kellett, hogy ne fusson össze a két scanf, mivel benne maradt az előzőből a sorvége, és azt rakta bele a pontazon-ba, és egyből ugrott a következő scanf-re. Úgy vannak a fájlban az adatok, ahogy kiírod őket..
Nem teszteltem le, de ennek ránézésre mennie kéne, ha kiveszed a &-t a változók elől.
-
KMan
őstag
mostmar korrektul bekeri, de szeretnem kiiratni a bekert a elemeket. elvileg egymasutan jonnek a fajlban nem? ez a szokoz amit beltettunk nem zavart bele?
elvileg nem kene hogy szokozok legyenek a fajlban, minden adat egymas utan jon
pl igy nez ki a fajl: A1.24.3B4.53.2C12.3 stb...
ezzel probaltam meg kiiratni de semmi.
void pontokkiir()
{
i=0;
for (i=0;i<5;i++)
{
fprintf(fpontok, ''%c%lf%lf'', &spontok[ i ].pontazon,
&spontok[ i ].kelet, &spontok[ i ].eszak);
}
} -
#194
bpx
őstag
FehérHolló
#189
bpx
őstag
válasz
FehérHolló
#189
üzenetére
pascalban így működik az eof (előre ''jósol''), c-ben viszont nem :/
pont a másik programozós topikban is felmerült valamelyik nap a probléma
itt van egy lehetséges példa a megoldásra: [link] -
KMan
őstag
a 0. elemet meg korrektul bekeri, de az 1-nel mar kihagyja a pontazon scanf-jet es egyszerre dobja ki a printf-et.
#include <stdio.h>
#include <stdlib.h>
main()
{
typedef struct {
char pontazon;
double kelet;
double eszak;
}t_pont;
int i=0;
FILE * fpontok;
t_pont spontok[4];
fpontok=fopen(''C:\\PONTOK.DAT'',''wb'');
for (i=0;i<5;i++)
{
printf(''A(z) %d pontazon: \n'', i);
scanf(''%c'', &spontok[ i ].pontazon);
printf(''A(z) %d kelet: \n'', i);
scanf(''%f'', &spontok[ i ].kelet);
printf(''A(z) %d eszak: \n'', i);
scanf(''%f'', &spontok[ i ].eszak);
}
fclose(fpontok);
} -
#190
caddie
csendes tag
FehérHolló
#189
caddie
csendes tag
válasz
FehérHolló
#189
üzenetére
Sztem logikus, hogy az utobbi. Nem varhatjuk el C++-tol, hogy nekunk elore olvas (sott elvarjuk, hogy ne olvasgasson ossze vissza). A I/O flagek a stream aktualis allapotat tukrozik, amikor pedig a kov. elem az eof, akkor bizony az majd csak a kovetkezo olvasaskor fog kiderulni.
-
#189
FehérHolló
veterán
caddie
#178
FehérHolló
veterán
Nem tudom megnézni azóta sehol. Magamtól szerettem volna látni, mert úgy az igazi, de akkor most már inkább kérdezek.
Az eof flag akkor állítódik, amikor a beolvasott cucc után vége van a file-nak (de eof-et még nem olvasott be), vagy akkor, ha magát az eof-et olvasta be a file-ból?
A te mondandód alapján utóbbi az igaz, de én eddig az előbbit hittem. Most akkor mi a helyzet?
Remélem érted, amit kérdezni szeretnék.
[Szerkesztve] -
KMan
őstag
Na
Azt szeretnem hogy nincs a fajlban semmi. A progi ugye megnyitja a meg nemletezo fajlt irasra. Aztan a standard inputrol egyesevel bekeri a struktura egyes tagjait, es ezt elmenti a fajlban. Majd miutan ennek a muveletnek vege, csak a biztonsag kedveert szeretnek vegigmenni a fajlon es kiiratni az elemeket, csak hogy minden tuti-e. -
Lortech
addikt
Már megint lemaradtak az indexek, használj [ i ]-t. (szóközök)
a scanf helyett nem fwrite-ot kellene hasznalni? Most nem foglalkozom azzal hogy kiiirassam a kepernyore, csak bele akarom irni a fajlba, ugyhogy a bill-rol kerem be az adatokat.
Mi tudjuk, hogy mit akarsz? scanf-fel feltöltöd a struktúrát, ha ezt ki is akarod írni akkor nyilván kell valamilyen fájlíró függvény is (pl fwrite, fprintf, puts), de nem egyik a másik helyett, hanem együtt.. Vagy kiírhatod a fájlba a semmit is. 
(vagy nem értem)
#186: Melyik a tömböd? A spontok. Akkor pedig a 2.
[Szerkesztve] -
KMan
őstag
#include <stdio.h>
#include <stdlib.h>
void main()
{
typedef struct {
char pontazon;
double kelet;
double eszak;
} t_pont;
FILE * fpontok;
t_pont spontok[4];
int i=0;
fpontok=fopen(''C:\\PONTOK.DAT'',''wb'');
for (i=0;i<4;i++)
{
printf(''A(z) %d pontazon: '', i);
scanf(''%c'', &spontok.pontazon);
printf(''A(z) %d kelet: '', i);
scanf(''%f'', &spontok.kelet);
printf(''A(z) %d eszak: '', i);
scanf(''%f'', &spontok.eszak);
}
fclose(fpontok);
}
a scanf helyett nem fwrite-ot kellene hasznalni? Most nem foglalkozom azzal hogy kiiirassam a kepernyore, csak bele akarom irni a fajlba, ugyhogy a bill-rol kerem be az adatokat.
[Szerkesztve] -
Lortech
addikt
Mondjuk úgy az egész egy merő hiba..Printf > printf, Scanf > scanf, flose > fclose. Beolvasásnál nem kéne indexelni a spontok-at?
printf(spontok); -- printf nem találja ki, hogy mit akarsz, csak char-t adhatsz neki. Le kell programozni egy eljárást, amiben minden mezőjét kiiratod külön-külön egy t_pont-nak. -
KMan
őstag
Hello, itt mi a hiba? Koszi es udv
#include <stdio.h>
#include <stdlib.h>
void main()
{
typedef struct {
char pontazon;
double kelet;
double eszak;
} t_pont;
FILE * fpontok;
t_pont spontok[4];
int i;
fpontok=fopen(''PONTOK.DAT'',''wb'');
for (i=0;i<4;i++)
{
Printf(''A(z) %d pontazon: '', i); Scanf(''%c'', &spontok.pontazon);
Printf(''A(z) %d kelet: '', i); Scanf(''%f'', &spontok.kelet);
Printf(''A(z) %d eszak: '', i); Scanf(''%f'', &spontok.eszak);
}
for (i=0;i<4;i++)
{
Printf(spontok);
}
flose(fpontok);
} -
#179
FehérHolló
veterán
caddie
#178
FehérHolló
veterán
Így már értem, hogy mit szeretnél kifejezni, köszi!
Nincs semmiféle rekurzió.
String egy saját stringosztály, aminek a megírása egy másik házi volt. Kiegészítettem néhány dologgal, ami kellett ehhez a feladathoz. Lényegében ugyanazt csinálja, mint a beépített string osztály (konverzió tekintetében is), de ennek tudom a pontos felépítését, így inkább ezt használtam fel újra.
[Szerkesztve] -
#178
caddie
csendes tag
FehérHolló
#177
caddie
csendes tag
válasz
FehérHolló
#177
üzenetére
Ha megnezted volna amit irtam, akkor latszik, hogy en egy konkret eseten irtam le az algoritmus mukodeset, nem altalanossagban...
Olvasol egy sor adatot (n db olvasas egy ciklusban), pont EOF elott er veget az olvasasi sorozat. Az ellenorzes ebben az esetben termesztesen azt mondja, hogy meg nincs EOF, igy elkezded a kovetkezo (n db) olvasast: Az elso adat olvasasakor EOF jon, de te sehol nem ellenorzod, hanem haladsz szepen tovabb es beolvasol n-1 db tovabbi 'adatot' es amikor megtetted csak akkor ellenorzol EOF-ot ujra.
Tovabbra sem ertem ugyanakkor, hogy mi a terminalo feltetele a String::restore() rekurziv hivassorozatnak. A restore ismet es ismet meghivja onmagat...
Azt sem ertem, hogy miert nevezted el a String osztalyodat Stringnek? A standard ugyanis definial egy std::string -et, rendkivul megteveszto!! -
#177
FehérHolló
veterán
caddie
#176
FehérHolló
veterán
Szerintem meg úgy van, hogy:
1. file megnyit
3. megnyitás ellenőriz
2. eof ellenőriz
3. olvas
4. eof ellenőriz
5. olvas
...
Az a String::restore(ifstream&) hívása. De a restore-okkal nincs gond, mert ha többet kell restore-olni egymás után, akkor nem kerül egyikbe sem hülyeség. Csak mint mondtam, a végén ráolvas mégegyszer, amikor már EOF volt.
[Szerkesztve] -
#176
caddie
csendes tag
FehérHolló
#175
caddie
csendes tag
válasz
FehérHolló
#175
üzenetére
Nyilvanvaloan ciklus kesesben van az EOF ellenorzes, mert te a kovetkezot csinalod:
file: < megnyit
adat < ellenoriz majd olvas
adat < ellenoriz majd olvas
EOF < ellenoriz (adatot olvasott elozoleg) majd olvas(EOFot meg minden mast ami mar nincs is)
... < ellenoriz (EOF volt!) es kilep
Mas:
tmpstr.restore(f);
A restore fuggvenyen belul mi ez a masik restore hivas. Valami rekurziv fuggvenyhivas?
[Szerkesztve] -
#175
FehérHolló
veterán
FehérHolló
veterán
Már igazából tök mindegy, mert elfogadták a házit, csak engem piszkál a dolog:
Adott ez a kódrészlet, biztos, hogy ebben van a hiba:
ifstream if2(costfile,ios::binary | ios::in);
if(if2){
while(!if2.eof()){
tmpc.restore(if2);
C.insert(C.size(),tmpc);
}
if2.close();
}
Ez eggyel többször olvas be, mint kellene. Tehát EOF után még beolvassa a semmit, és nem nagyon értem, hogy miért. Biztos tök egyszerű a válasz, csak én vagyok a buta.
a restore(ifstream&) tagfüggvény így néz ki:
void restore(ifstream& f){
String tmpstr;
f.read((char*) &costumer_id,sizeof(unsigned));
tmpstr.restore(f);
f.read((char*) &to_pay,sizeof(unsigned));
f.read((char*) &paid,sizeof(unsigned));
f.read((char*) &item_out,sizeof(unsigned));
this->set_name(tmpstr);
}
[Szerkesztve] -
#174
amargo
addikt
FehérHolló
#173
amargo
addikt
válasz
FehérHolló
#173
üzenetére
Szerk: Hülyeséget keztem leírni, az előbb.
[Szerkesztve] -
#173
FehérHolló
veterán
satchmo
#172
-
#171
amargo
addikt
FehérHolló
#167
amargo
addikt
válasz
FehérHolló
#167
üzenetére
-
#169
Jester01
veterán
FehérHolló
#167
Jester01
veterán
válasz
FehérHolló
#167
üzenetére
Szerintem várd meg míg Amargo megmagyarázza, mert nekem sem tiszta mi előnye van a 2 time hívással szemben. Ráadásul ezek windowsos varázslatnak tűnnek.
-
#167
FehérHolló
veterán
amargo
#165
FehérHolló
veterán
Erről rögtön levágta volna a gyakvezér, hogy nem én csináltam.
Két sima time()-al megoldottam a problémát.
Köszi szépen a segítséget! Ezt elrakom későbbre emésztgetni (2 órát aludtam, és most nem jön össze semmi...).
Csak eléggé rámijesztettek, amikor elkezdtek mellettem 300soros időkezelésről beszélgetni a többiek.
A union nem struktúra.
[Szerkesztve] -
#165
amargo
addikt
FehérHolló
#163
amargo
addikt
válasz
FehérHolló
#163
üzenetére
union { // Struktura
LONGLONG li;
FILETIME ft;
} CreateTime, EndTime, ElapsedTime;
SYSTEMTIME SYSstart, SYSend, SYSelapsed;
GetLocalTime(&SYSstart);
Sleep(600);
GetLocalTime(&SYSend);
SystemTimeToFileTime(&SYSstart, &CreateTime.ft);
SystemTimeToFileTime(&SYSend, &EndTime.ft);
ElapsedTime.li = EndTime.li - CreateTime.li;
FileTimeToSystemTime(&ElapsedTime.ft, &SYSelapsed);
Bár a dátumra nem tökéletes, de én uniont hazsnálnék a célra. -
#164
caddie
csendes tag
FehérHolló
#161
caddie
csendes tag
válasz
FehérHolló
#161
üzenetére
En megmondom oszinten nem ertem mi a kerdes. Kiprobalod aztan majd kiderul.
-
#162
Jester01
veterán
FehérHolló
#161
Jester01
veterán
válasz
FehérHolló
#161
üzenetére
Mire is kell itt a ctime?
-
#161
FehérHolló
veterán
FehérHolló
veterán
Itt is feltenném a kérdést.
Ennek a második bekezdésében van leírva: [link]
A kivételi és visszahozatali időt time()-al tárolnám, majd ctime()-al hasonlítanám őket.
[Szerkesztve] -
caddie
csendes tag
válasz
norbiphu
#159
üzenetére
A kodot nem neztem, de a copy konstruktor azert hivodik, mert az operator*() egy temporalis objektumot 'hoz letre' es ez adodik ertekul a b-nek.
# 1 b = b * 2
# 2 b = [ c ]
# 3 b = c
Ez lenne a normalis megvalositasa egy opeartor*() -nak, amely 'free' esetleg friend fuggvenykent van megvalositva.
[Szerkesztve] -
norbiphu
őstag
üdv!
adott ez a kód [link]
azt nem értem, hogy b = b *2 - nél, meg b = 3 * b miért hívodik meg a copy konstruktor
.
addig oké, hogy operator* miatt kiirja az szorzót, utána pedig operator= - höz ugrik.
ott viszont elvesztettem a fonalat, hogy miért ez a sorrend.
köszi a segítséget
-
Pitasama
csendes tag
Sziasztok!!!
Bocs a késői jövetelért, de már annak is örülök, h idetaláltam...
Szóval... Eléggé nagy gázban vagyok.... egy feladatot kéne megcsinálnom, de fingom nincs hozzá nem is értem... :S
Szóval ha esetleg meg tudnátok csinálni nagyon megköszönném!
Készítsen el egy osztályt (zeneszám) zeneszámok tárolására!
Legyen egy max. 40 ch hosszú attribútuma az előadó, egy max 40 ch hosszú attribútuma
a zene címének, továbbá egy egész változója a szám hosszának másodpercekben történő
tárolására. Lássa el az osztályt a zegyes változók bállítására, ill. kiíratására
szolgáló metódusokkal! (setArtist, getArtist, setTitle, getTitle, setLength, getLength)
Ebből az osztályból hozzon létre 3 objektumot és alkalmazza rájuk a megírt metódusokat!
Ez lenne az. Kérlek titeket, h ha vki tudja a megoldást, hétfő este 8-ig próbálja vhogy hozzám eljuttatni... és lehetőleg úgy, h az objektumos részt zárójellel a szöveg mögött elmagyarázva, h mi miért van.
Előre is köszönöm!!!!
jah és lehetőleg erre a mélre küldjétek el nekem mert nem fix, h elérem az oldalt a kóterból.
Köszi
jóccakát mkinek!!! -
Zulfaim
csendes tag
Befejeztem.
Ez lett a vége:
#include <cstring>
#include <iostream>
#include <fstream>
using namespace std;
class buffer {
char* buff;
int size;
public:
buffer():buff(0),size(0){}
buffer(const buffer&);
buffer& operator=(const buffer&);
buffer& operator+=(const buffer&);
bool operator==(const buffer&);
buffer& buffer:: operator+=( const char*);
buffer& buffer:: operator=(const char*);
bool buffer:: operator==(const char*);
friend void beolvas(buffer &);
friend void kiir(buffer &);
friend ostream& operator<<(ostream& s, const buffer b);
friend istream& operator>>(istream& s, const buffer b);
~buffer(){ delete[] buff; }
};
buffer::buffer(const buffer& e)
{
buff=new char[(size=e.size)+1];
if (e.buff)
strcpy(buff,e.buff);
}
buffer& buffer:: operator+=( const char* value)
{
char* temp=new char[size = strlen(buff)+ strlen(value) +1];
strcpy(temp,buff);
strcat(temp, value);
delete[] buff;
buff = temp;
return *this;
}
buffer& buffer:: operator+=(const buffer& e)
{
char* temp=new char[size+=(e.size+1)];
strcpy(temp,buff);
strcat(temp,e.buff);
delete[] buff;
buff=temp;
return *this;
}
buffer& buffer:: operator=(const char* value)
{
delete[] buff;
if( size=strlen(value))
{
buff=new char[size+1];
strcpy(buff,value);
}
return *this;
}
buffer& buffer:: operator=(const buffer& e)
{
if( this!= &e)
{
delete[] buff;
buff=new char[size=e.size];
strcpy(buff,e.buff);
}
return *this;
}
bool buffer:: operator==(const char* value)
{
if(size==strlen(value)) return true;
else return false;
}
bool buffer:: operator==(const buffer& e)
{
if(size==e.size) return true;
else return false;
}
ostream& operator<<(ostream& s, const buffer b)
{
for(int i=0;i<b.size;++i)
{
s<<b.buff;
}
return (s);
}
int karakterek_szama()
{
fstream fp(''c:\\txt.txt'',ios::in);
char c;
int k=0;
while(!fp.eof())
{
fp.get(c);
++k;
}
fp.close();
return k;
}
istream& operator>>(istream& s, buffer b)
{
int k=karakterek_szama();
delete[] b.buff;
b.buff=new char[(b.size=k)+1];
for(int i=0;i<b.size;++i)
{
s>>b.buff;
}
return (s);
}
void beolvas(buffer& b)
{
int k=karakterek_szama();
delete[] b.buff;
b.buff=new char[(b.size=k)+1];
fstream fp(''c:\\txt.txt'',ios::in);
while(!fp.eof())
{
fp.getline(b.buff,b.size);
}
fp.close();
}
void kiir(buffer& b)
{
fstream fp(''c:\\txt.txt'',ios:
ut);
fp<<b.buff;
fp.close();
}
int main()
{
buffer b;
buffer a;
beolvas(b);
char s[7]=''+FUZES'';
char s2[11]=''ASDFWERGWE'';
a=s2;
cout<<(a==b);
cout<<endl;
b+=s;
cout<<b;
cout<<endl;
b+=a;
cout<<b;
kiir(b);
cin.get();
return 0;
}
[Szerkesztve] -
Zulfaim
csendes tag
Most a program beolvasás részét próbálom megoldani, de valami probléma van vele.
int karakterek_szama()
{
fstream fp(''c:\\txt.txt'',ios::in);
char s[100];
int k=0;
while(fp>>s)
++k;
fp.close();
return k;
}
istream& operator>>(istream& s, buffer b)
{
int k=karakterek_szama();
delete[] b.buff;
b.buff=new char[(b.size=k)+1];
for(int i=0;i<b.size;++i)
{
s>>b.buff;
}
return (s);
}
void beolvas(buffer b)
{
fstream fp(''c:\\txt.txt'',ios::in);
while(fp>>b.buff)
fp.close();
}
A karakterek_szama() fgv.-el meghatározom, hogy mennyi memóriaterület kell.
Ezt lefoglalom és kiolvasom a fájl tartalmát.
A beolvas függvény friend.
Nem működik.
[Szerkesztve] -
caddie
csendes tag
1, Osztalyon kivul definicio:
- letisztult marad az osztaly interface ( kod olvashatosag )
- tipikusan kulon header / forras fileokba rendezzuk az osztaly deklaraciot es definiciot, hogy az osztaly implementaciojanak megvaltoztatasakor ne kelljen ujraforditani mindne olyan forrasfilet, amely csak az interface-tol fugg (erre vannak meg szofisztikaltabb modellek is pl: pimpl idiom)
- C++ -ban az a szokas, hogy az inline fuggvenyeket definialjuk osztalyon belul, amelyek 1-2 sorosak, a tobbit pdig osztalyon kivul definialjuk
2, using namespace std;
- ezt alapbol nem ajanlott hasznalni, mert az std nevterben levo osszes elerheto nevet beemeli, helyette specifikusan a hasznalt neveket szokas / vagy meginkabb minositeni szokas a hasznalt dolgokat
- ha header file-ba irod be, akkor az osszes forrasfile amely felhasznalja a headert keretlenul is megkapja az osszes std nevterben levo elerheto nevet
- nevtereket pont azert talaltak ki, hogy particionalva legyenek (felosztva) a nevek. using namspace std beemelesevel pont ezt iktatjuk ki, hiszen minden beemelunk a ''globalis'' nevterbe
3, inicializalasi lista:
- amikor a konstruktor torzsebe adod meg, hogy adott member valtozonak milyen kezdoerteket szeretnel megadni, akkor eloszor letrejon az objektum, lefut a default konstruktora, majd egy kulon fuggvenyhivas kereteben masolodik at a kezdoertek. inicializalasi listaval az adott valtozo konstrualasakor mar kezdoertekkel latod el azt (tehat hatekonyabb es igy az elegans, erre talaltak ki az inicializalasi listat).
4, size_t: STL az egy peldas kod, erdemes annak a filozofiaja szerint dolgozni, annak eszkozeit hasznalni es amennyire ertelmes idomulni hozza.
5. NULL nincs benne a C++ szabvanyban, teljesen forditofuggo, hogy van-e benne, mi van mogotte (makro) es hogy a fordito kov. verziojaban is benne lesz-e. amugya 0 -nak implicit konverzioja van pointerekre.
6. a postfix novelo operatorok definicio szerint egy temporalis objektumba mentik a valtozo eredeti erteket, majd megnovelik a valtozo erteket, a regi erteket pedig visszadjak. a prefix novelo operator cask novel es visszaad, ergo a postfix min 2x annyi muveletet vegez (szamszeruleg, valoszinuleg a fordito ugyanis kioptimalizalja). A lenyeg, hogy prefix kell mindenhova kiveve ahova postfix kell
Roviden ennyi, remelem nem hagytam ki semmit -
caddie
csendes tag
Hat a kod sok-sok sebbol verzik:
- buff = ' 'zzz' ' ez mi ez?, miert nem hasznalsz inicializalasi listat?
- kiiro operatornak nyugodtan lehet const buffer& -t atadni
- += operatornt - minimalisan - igy modositanam:
)
buffer& buffer:: operator+=( const char* value)
{
char* temp=new char[size = strlen(buff)+ strlen(value) +1];
strcpy(temp,buff);
strcat( temp, value);
delete[] buff;
buff = temp;
return *this;
}
teljesen feleslegesen masolgatsz es foglalsz memoriat. Jelen pillanatban nem ellenerozom, hogy az atadott pointer null pointer / van legalabb 1 karkater benne stb. Ezt belehekkelheted.
- ertekado operatornal, bevallom nem ertem ezt:
for(int i=0;i<size;i++)
{
buff=e.buff;
}
ez mi ez?
talan
for(int i=0;i<size;i++)
{
buff [ .i. ] =e.buff [ .i. ] ; // konvertalas miatt :(
}
? De ez sem jo, mert a vegere nem masolja oda a '/0' -t. Sztem erdemesebb lenne hasznalni a strcpy-t
- kiiro operator hasonloan beteg
- nem latok racionalis okot, hogy meirt van a += es az egyik ertakado operator az osztalyon belul definialva, a tobbi meg kivul.
- copy konstruktor is beteg, keves memoriat foglalsz es utana u.a. a hulyeseg van mint ertakado operatornal
- sztem teljsen feleslegesen a postfix incerementalo operatorok
[Szerkesztve] -
muxik koszi, 5 elemu lett a tomb indexek 0-4 ig, mostmar jo a for ciklus.
(vagy nem értem)
.
ut);
Új hozzászólás Aktív témák
Hirdetés
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- Bezámítás! Lenovo Legion 5 15IMH05H notebook - i5 10300H 16GB DDR4 256GB SSD 1TB HDD GTX 1660Ti W10
- iKing.Hu - Apple MacBook Pro 13 M1 Touch Bar 2020 Használt, karcmentes 3 hónap garanciával
- Országos! KÉSZPÉNZES - UTALÁSOS VIDEOKÁRTYA FELVÁSÁRLÁS! Korrekt áron! AMD!
- Game Pass Ultimate előfizetés azonnal, élettartam garanciával, problémamentesen! Immáron 8 éve!
- BESZÁMÍTÁS! Gigabyte H610M i5 12400F 32GB DDR4 512GB SSD RTX 3060Ti 8GB Rampage SHIVA Be Quiet! 730W
Állásajánlatok
Cég: PCMENTOR SZERVIZ KFT.
Város: Budapest