Új hozzászólás Aktív témák
-
dobragab
addikt
válasz
feketeg5
#5599
üzenetére
Megírni nem fogom helyetted, de azért ötleteket adok.
Dönthetsz, hogy szövegként dolgozol-e vele, vagy számként. Előbbi esetben a karaktereket egyszerű összehasonlítani és a hosszát meghatározni. Ha számként használod, akkor egy kicsit több matek kell hozzá, de szebb a megoldás.
-
feketeg5
csendes tag
Sziasztok!
Ha valaki segít megoldani az alábbi feladatot, hálám örökké üldözni fogja. A szombati vizsgámhoz kellene megírnom sima C-ben, úgymond "egyetemes" programozással, nem összebarkácsolva, inputellenőrzésekkel stb. Nekifeküdtem már sokszor a programozásnak, de egyszerűen nem áll rá az agyam.
A feladat a következő:
400 nál nagyobb egész számokat kellett bekérni és azokat vizsgálni. Tömb méret nem volt megadva. Csak a példában 5 helyiértékes szám volt a legnagyobb azért azt vettem alapul. A számnak páratlan számjegyűnek kellett lennie , és tükrösnek (Pl:12321). A feladat hogy addig kérd be a helyes számot amíg 2 helyes számot nem kapsz. Hiba üzenetetek:
-nem szám a bemenet
-400nál kisebb a bemenet
-Nem páratlan számjegyű.
-Nem tükrös számÉletet mentene a segítség, ha tudom, viszonoznám!
-
dobragab
addikt
válasz
EQMontoya
#5596
üzenetére
Ó én mindent, és meg is van az értelme.
Elsődlegesen Win8.1 + Classic Shell.
Ezen kívül:
arch linux + gnome3
ubuntu 14.04 + cinnamon
linux mint + cinnamon (már nem használom)
ubuntu 16.04 + kde5 (csak kipróbáltam, lassan kuka)
win7
win10 + classic shellMindez egy gépen. Amúgy az egyik cinnamonra kifejezetten büszke vagyok
-
dabadab
titán
-
-
huwil
csendes tag
válasz
EQMontoya
#5590
üzenetére
Köszi a segítséget, közben nekem is sikerült úgy ahogy összedobnom, csak akadtak problémák, nevezetesen elkezdett sírni a program, hogy pipe meg a fork funkciók nincsenek definiálva...aztán leesett (meg utána olvastam), hogy ez valószínűleg a windows-os compiler miatt van, ami a linuxos dolgokat természetesen nem nagyon tudja lekezelni
szóval leszedtem egy elvileg működő compilert (cygwin), azzal már nem sír, konkrétan annyira nem csinál semmit, hogy még hibát se dob ki...mindegy, van egy elvileg működő kódom, a többit meg kimagyarázom, de azért köszi a helpet! 
-
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?
-
dabadab
titán
válasz
aviator
#5584
üzenetére
"Azért lett pointer a tömb típusa mert később a koordináták címeire lesz szükség."
Ez a hiba. Ha szükség van a koordináták címeire, akkor veszed a címüket a & operátorral
Azzal, hogy az a tömb koordinata* típusú, azt mondtad, hogy ez egy pointert tartalmaz egy koordinata structra - és ez ezt is jelenti. Amikor létrehozod a haromszoget, akkor az létrejön, lesz benne három pointer, amik nem mutatnak sehova (pontosabba valami tök véletlenszerű helyre mutatnak), persze, hogy úgy elszáll a program.
Kénytelen leszel feltölteni ezeket a pointereket kézzel, pl. úgy, hogy foglalsz három koordinata structot, aztán azoknak a pointereit berakod (és amikor nem kellenek, akkor majd nyomsz rájuk egy free-t is). Ez remek dolog, ha valamiért te szeretnéd foglalni ezeket vagy más helyen lefoglalt structok pointerét akarnád felhasználni, viszont úgy tűnik, hogy egyáltalán nem ezt akarod, hanem azt, hogy a fordító hozzon létre neked három koordinata structot, meg aztán majd szabadítsa is fel a megfelelő időben.Szóval ez kell neked:
typedef struct haromszog
{
koordinata csucsok[3];
}haromszog;
haromszog triangle;
scanf("%d %d %d", &(triangle->csucsok[0].x),&(triangle->csucsok[0].y),&(triangle->csucsok[0].z)); -
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.
-
huwil
csendes tag
Hello! Szeretnék egy kis segítséget kérni. Holnap (szerda) délelőttre kellene ezt a két egyszerűnek tűnő programot megcsinálni és kellene hozzá segítség (konkrétan megcsinálni):
Irjon C nyelvu programot, ami
letrehoz ket csovezeteket (ket file deszkriptor part)
elforkol
a szulo elkuldi a sajat pidjet a gyerkmeknek az egyik csovon
a gyermek kiirja a kepernyore es visszkuldi egy az ovet a masik csovon
megszunnek a processzek (a szulo megvarja a gyereket)
és
Irjon C nyelvu programokat, ami
letrehoz egy nevesitett csovezeteket (bejegyzes az fs-en)
megnyitja
beleir valamit
kozben egy masik program kiolvassa a csovezetekbol
ezutan az elso program szinten ir bele valamit
a masik program ujbol kiolvassa
a processzek megszunnek es az elso program eltunteti a nevesitett csovezeteket
Előre is köszönöm, ha valaki tud és segít is benne!
-
-
EQMontoya
veterán
válasz
dobragab
#5579
üzenetére
Nem a típustól függ, hanem az elhelyezkedéstől.
nyilván sizeof((void*)tomb) == sizeof(&tomb).Viszont két, azonos típusra mutató ptr nem feltétlen ugynaakkora. Persze x86-on nem lesz különbség, de amúgy, főleg embedded rendszerek esetén lehet. (mondjuk stack, heap és static között)
-
-
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?
-
bepken
veterán
válasz
dobragab
#5563
üzenetére
akkor ezek szerint a string.h is használható! ezzel meg is oldódott a problémám, egy strlen segítségével könnyedén meglett az a fránya üres sor is
(másképp én nem tudtam megoldani)el is fogadta a kódot, úgyhogy köszi szépen
(hamarosan jövök újabb kérdésekkel 
)ez a feladat nem kifejezetten verseny feladat, csak egy beugró. szerencsére/sajnos itt még alap dolgok vannak. minden esetre én egyelőre vizsgán szeretnék átmenni, úgyhogy az egyszerűsítésnek csak örülni tudok
-
dobragab
addikt
Neked az identifier.c-t kell megírnod, amiben van egy megadott deklarációjú függvény, abba bármit include-olhatsz. A feladat nem várja, hogy a ctype.h-t ne használd, sőt.
Üres sor problémára: az üres sort a gets üres sztringként olvassa be (""), így üres sztringként kapod meg a nevet.
Btw szégyen, hogy versenyen a skeleton-ban gets van.
-
bepken
veterán
sziasztok,
közel vagyok egy feladat megoldásához, de sajnos nem vagyok benne biztos, hogy jó úton indultam el....
vizsgálni kell többek között, hogy az adott sor tartalmaz e nagybetűt és számot. na most ezt eddigi ismereteim szerint legegyszerűbben a <ctype.h> könyvtár függvényeivel tudom megoldani. viszont a feladatban van egy előre megadott main függvény, amiben ez a könyvtár nincs megadva.
gondolom include csak elől szerepelhet, bár compiler nem szólt függvényen belül sem. de esetleg meg lehet ezt oldani az említett fv.könyvtár nélkül is? mármint...gondolom ezt várná a feladat.a másik problémám, amit viszont egyáltalán nem tudtam lekezelni: az a példabemenet 7. sorában lévő üres sor. ezt hogy a fenébe kellene lekezelni, hogy a függvény megfelelően működjön?
ezeket leszámítva az általam írt megoldás minden bemenetre megfelelő értéket adott. egyelőre általánosságban kérdezősködök, de természetesen tudok mutatni kódot is.
köszi előre is,
bepken -
bepken
veterán
azt hiszem, így már leesett, miért kaptam ezeket az értékeket (minden fehér karaktertől eltérőt összeszámoltam a bemenetről
) köszi szépen a gyors választ! még talán annyi, hogy ha az else if (allapot == KINT) helyett miért nem írható pl: else if (1) - ezt a részét még nem értem. mármint ha KINT állapotban vagyunk, akkor beugrik erre az ágra és átváltja az értéket BENT-re, majd a ciklus elején lehet újra KINT-re változik. na de miért épp ez a feltétel?
-
kispx
addikt
Ha csak else ág lenne, akkor azokat a karaktereket számolná össze, ami nem szóköz, új sor vagy tabulátor.
Így a szavak kezdőkarakterét számolja össze, ami megegyezik a szavak számával (mivel minden szónak csak egy kezdőkaraktere van).Ezért kellett az állapotgép (KINT, BENT), hogy meglehessen különböztetni a kezdőbetűt, a szó belsejében lévő betűtől.
-
bepken
veterán
sziasztok,
még csak ismerkedek a C programozási nyelvvel (bár nem ez az első nekifutásom) - egyszer már elolvastam a Kernighan-Ritchie féle könyvet, most elölről kezdtem és a példákon is végig megyek.
van (még egészen az elején) egy példakód, aminek egy "aprócska" része nem igazán világos számomra: 1.5.4. Szavak számlálása fejezet példakódjáról van szó.
az egészből egész pontosan ezt a kódrészletet nem értem:
if (c == ' ' || c == '\n' || c == '\t')
allapot = KINT;
else if (allapot == KINT) {
allapot = BENN;
++nw;
}egész konkrétan az else if ágat nem értem belőle. az megvan, hogy a két állapot (KINT/BENN) között kell váltogatni, de miért így van megírva az else if feltétele? ha jól értem, csak azért, hogy beugorjon abba az ágba, átváltson BENN értékre és növelje az nw változó értékét...jól értem? csak mert ülök már felette jónéhány perce
egyébként mire leírtam mégis csak koppanni látszik...na de akkor annyit ha segítenétek, hogy miért nem lehet a helyén egy sima else ág? vagy az allapot == KINT feltétel helyén egy akármilyen igaz feltétel?
köszi előre is a segítő szavakat
(remélem, nem kérdezek nagy baromságot)üdv,
bepken -
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});
-
dabadab
titán
És ha már itt pointerezünk, akkor érdemes megemlíteni, hogy vannak dolgok, amiknek nincs címe, pl. általában literáloknak (a stringek kivételek) vagy függvények visszatérési értékének vagy műveletek eredményének:
double x;
double *p;
double **pp;
x=1.0;
p=&x; // OK
pp=&p; // OK
pp=&(&x); // error
p=&1.0; // error
p=&sin(x); // error -
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.
-
Gyb001
senior tag
Üdv ismét.
Lenne egy glut problémám. Nem jelenik meg egy textúra, csak az átlag színe, szerintetek mi lehet a probléma?glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture[6]);
drawBox(100.0f,GL_QUADS);
drawBoxAkárhol próbálom a programon belül textúrázni, sehol nem működik, Viszont ugyanaz a textúra egy másik obijektumon megjelenik.
pl:
-
-
EQMontoya
veterán
int64_t g = 0;
do
{
int64_t wg_index = selected_wg[g];
if (wg_index >= num_workgroups)
wg_index -= num_workgroups;
source->serialised = ncmem_peek_nc (serialised, ncmem_remaining (serialised));
ncmem_flatten (source->serialised);
actor_senda (workgroups->actors[wg_index], send_msg, source, sizeof (fred_fix_source_t));
if (++g == num_selected_wg)
break;
} while (true);Csak az eleje meg a vége a lényeg.
Én röhögőgörcsöt kaptam, ilyen nincs. És van, baszd meg, benne a repoban. -
nonsen5e
veterán
Köszönöm, megnézem a getch(), meg átdolgozom a ciklust is kicsit.
Majd próbálok kitalálni / keresni valamit a várakoztatásra, rögtön az elején tudtam, hogy ez nem lesz jó, de jelenlegi "tudásom" alapján egyelőre ezt tudtam kigányolni belőle, addig is tudom folytatni a program többi részét.
Semmi házi, vagy beadandó vagy ilyesmi. Saját szórakoztatásomra tanulgatom a nyelvet, úgyhogy minden konstruktív kritikát szívesen fogadok! -
Karma
félisten
válasz
nonsen5e
#5518
üzenetére
Onnantól kezdve, hogy conio.h (brrr Borland), elég egyszerűen meg lehet oldani. A getch() visszaadja az utoljára lenyomott karaktert, ami a kbhit után nem fog várakozni, hanem visszaadja az utoljára lenyomottat.
Mondjuk szerintem gondold át egy kicsit, hogy mit csinál a != operátor abban az esetben, ha valamilyen okból túlszalad a seconds2 változód a seconds-on, és nem kéne helyette valami más operátor.
Harmadrészt egy középiskolai háziban mondjuk szódával elmegy a busy wait, de afölött már utána kéne nézni, hogy lehet várakozni while ciklusban 100%-on pörgetett CPU nélkül.
-
nonsen5e
veterán
Sziasztok!
Egy program részeként olyasmit szeretnék létrehozni, hogy elindul egy visszaszámláló ciklus, ami vagy akkor lép ki amikor lejár az idő, vagy akkor ha lenyomok egy bizonyos billentyűt. Viszont a program tárolja is el annak a lenyomott billentyűnek az értékét, így ahogy néztem a khbit() függvény kiesik.
Ez a kód jelenleg működik is (addig fut amíg le nem telik az idő, vagy nem nem nyomok egy billentyűt), csak a while után én meg is szeretném valahogyan vizsgálni a leütött karaktert.
scanf() / getch() / getchar() pedig azért esik ki, mert a következő karakterleütésig szünetelteti a program futását.#include <stdio.h>
#include <time.h>
#include <conio.h>
int main ()
{
time_t seconds;
time_t seconds2;
seconds = time(NULL)+3;
seconds2 = 0;
while (!kbhit() && seconds2!=seconds){
printf("töltelékszöveg, hogy lássam, hogy működik.\n");
seconds2=time(NULL);
}
return 0;
} -
dobragab
addikt
válasz
aleister
#5511
üzenetére
Elvileg VS2015 már (!) támogatja a C99-et is. Lassan ideje volt, elvégre jövőre nagykorú lesz a szabvány. Ennek ellenére C-hez ne használj VS-t, pl. a scanf miatt tuti szívni fogsz, de a szabványt is máshogy értelmezi, mint kéne.
Én egy MinGW-t javaslok, CodeBlocks-szal együtt még kényelmes is.
-
aleister
veterán
Sziasztok!
Most kezdtem el a C-vel foglalkozni. Tudnátok egy olyan fordítót ajánlani, ami 64 bites W10 alatt működik? Konkrétan az alap ANSI C-t nyúzom. Próbálkoztam online compilerekkel, de már egy sima scanf-nél sem működtek jól. Aztán leszedtem a miniGW-t, de el sem indult. Végül az MS Visual Studio 2015-öt, de abban meg csak C++ és C# lehetőséget találtam, mezei C-t nem.
Csak gyakorlásra kell. Nem kell semmi extra fícsör.
-
alapz@j
tag
A PellesC-vel nem volt gondod? Én akkor szedtem le a gépemről, amikor kiderült, hogy a totál ansi C forrásból készülő Lua.exe-t (a Lua nyelv értelmezője) csak a PellesC-vel fordítva nem működik rendesen, pedig azzal még a barebone Tiny C Compiler (tcc) is megbirkózott...
-
mepet
addikt
válasz
dobragab
#5507
üzenetére
C++-ul nem értek, de legalább ma is tanultunk valamit. Kézzel pötyögtem a kódot, és én nem literal méretét néztem, az életben eszembe nem jutott volna ilyen, hogy "visszafelé kompatibilitás miatt" ugyanaz a típus több byte-ot foglalhat csak azért, mert literal...
char a='a';
printf("%zu", sizeof(a));
printf("%zu", sizeof(+a));Ez pedig 14-et dob C-ben, és itt az a magyarázat, amit én mondtam, de persze mint kiderült a két kód között is van különbség...
[szerk] PellesC built-in complier LCC alapokon, -std:C11
-
dobragab
addikt
C++-ban a character literal típusa char, mégpedig azért, hogy működjenek az overload-ok (pl. operator<<). Az unáris operator+ igazából semmit nem csinál, csakis azért van, hogy le tudd írni:
int i = +5;
Illetve mégis csinál valamit: minden egész művelet operandusai minimum int-re kasztolódnak fel, és a végeredménye is minimum int. Ezért +'a' már int típusú. Tehát az output C++-ban 14.C-ben a character literal típusa int, az unáris operator+ esetén ugyanúgy megvan az upcast, csak ugye int-ről int-re. C-ben a végeredmény 44.
%zu csak C99-ben és C++-ban van, így C-ben kell az -std=c99. MSVC-t ne használj C-re
Fogadjunk, hogy te a C++-os megoldást mondtad -
mepet
addikt
itt feldobtak egy szuperegyszerű "mit ír ki" feladatot.
printf("%zu", sizeof('a'));
printf("%zu", sizeof(+'a'));A választ tudom, mert kipróbáltam. Csak tippelni tudok, mit csinálhat az a +. Jól tippelek, csak ennyi a megfejtés: 0(int)+akármi(char) = akármi(int), és ezért az a válasz, ami?
-
![;]](http://cdn.rios.hu/dl/s/v1.gif)
) 
)
Köszi a felvilágosítást.
locks-ot találtam. egyéb ötlet?
Ú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!
- Házimozi haladó szinten
- Milyen notebookot vegyek?
- Fúziós energiát vásárol a Google
- Teljes verziós játékok letöltése ingyen
- iPhone topik
- Kamionok, fuvarozás, logisztika topik
- Apple asztali gépek
- Melyik tápegységet vegyem?
- Spórolós topik
- NVIDIA GeForce RTX 5070 / 5070 Ti (GB205 / 203)
- További aktív témák...
- PlayStation 4/5 kontroller analóg cseréje HALL TMR érzékelősre, 1 év garancia!!! Nincs többé drift!!
- PlayStation 5/4 kontroller analóg cseréje HALL TMR érzékelősre, 1 év garancia!!! Nincs többé drift!!
- XBOX ONE/Series kontroller analóg cseréje HALL TMR érzékelősre, 1 év garancia!!! Nincs többé drift!!
- XBOX Series S 512GB, 6 hó garanciával Bp-i üzletből eladó!
- Dell Latitude 5400 / i5-8365u / 8Gb DDR4 / 256Gb SSD / FHD IPS / Excellent akku
- Bomba ár! Lenovo X1 Yoga 1st - i7-6G I 8GB I 256SSD I 14" WQHD I HDMI I W10 I CAM I Garancia!
- VÉGKIÁRUSÍTÁS - REFURBISHED - HP Elite / ZBook Thunderbolt 3 docking station
- ÁRGARANCIA!Épített KomPhone Ryzen 7 9800X3D 32/64GB RAM RX 9070 XT 16GB GAMER PC termékbeszámítással
- DELL PowerEdge R730xd 26SFF rack szerver - 2xE5-2680v3 (24c/48t, 2.5/3.3GHz), 64GB RAM, 10G, H730p
- PS3 Játékok 1500Ft/db - RÉSZLETEK A LEÍRÁSBAN
Állásajánlatok
Cég: Promenade Publishing House Kft.
Város: Budapest
Cég: PC Trade Systems Kft.
Város: Szeged