-
Fórumok
Mobilarena - mobil fórumok
Okostelefonok Mobiltelefonok Okosórák Autó+mobil Üzlet és Szolgáltatások Mobilalkalmazások Tartozékok, egyebek Mobilarena blogokPROHARDVER! - hardver fórumok
Notebookok TV & Audió Digitális fényképezés Alaplapok, chipsetek, memóriák Processzorok, tuning Hűtés, házak, tápok, modding Videokártyák Monitorok Adattárolás Multimédia, életmód, 3D nyomtatás Tabletek, E-bookok Nyomtatók, szkennerek PC, mini PC, barebone, szerver Beviteli eszközök Egyéb hardverek PROHARDVER! BlogokIT café - infotech fórumok
Infotech Hálózat, szolgáltatók OS, alkalmazások SzoftverfejlesztésGAMEPOD - játék fórumok
PC játékok Konzol játékok MobiljátékokLOGOUT - lépj ki, lépj be!
LOGOUT reakciók Monologoszféra FototrendFÁRADT GŐZ - közösségi tér szinte bármiről
Tudomány, oktatás Sport, életmód, utazás, egészség Kultúra, művészet, média Gazdaság, jog Technika, hobbi, otthon Társadalom, közélet Egyéb Lokál PROHARDVER! interaktív
-
Frissítve: 2014-04-25 14:12 Téma összefoglaló
Új hozzászólás Aktív témák
-
alapz@j
tag
-
alapz@j
tag
-
alapz@j
tag
-
alapz@j
tag
Ezt írtam rá tegnap:
void t1(void) {
char msg[16];
strcpy(msg, "Hello!");
puts(msg);
}
void t2(void) {
char msg[16];
puts(msg);
}
int main(void) {
t1();
t2();
return EXIT_SUCCESS;
}Mivel a t1 és t2 függvényeknek ugyanolyan méretű a kezdeti stack frame-je, így a t2 hívásakor a char[16] ugyanarra a memóriaterületre esik és a puts szépen kiírja az előző függvényből ott maradt Hello!-t
-
alapz@j
tag
-
alapz@j
tag
Én magam is leadnék egy szavazatot a goto és az early return mellett :) közben pedig bedobok egy lehetséges megoldást a fentebb is vázolt hibakezelés közbeni erőforrás-deallokálási problémákra, sajnos csak a GCC fordítót használóknak:
void free_buffer(char ** buffer) {free(*buffer);}...char *buffer __attribute__ ((__cleanup__(free_buffer))) = malloc(20);
Amikor a buffer kimegy a scope-ból, auto meghívja a cleanup attribútumban megadott függvényt.
http://echorand.me/site/notes/articles/c_cleanup/cleanup_attribute_c.html -
alapz@j
tag
Emlékeim szerint a C szabványban nem szerepel, hogy a char előjeles vagy előjel nélküli lenne, ezt ráhagyja az implementációra. A fordítók pedig jellemzően az int és társai után a char-t is előjelesként kezelik alapértelmezetten, nem véletlenül vannak a -funsigned-char kapcsolók és társaik..
-
alapz@j
tag
A Nuwen.net-es MinGW-ben például van pcre / regex.h, nem kell hozzá Cygwin. Ne terjesszünk már olyan butaságokat, hogy a "A C-t nem a windows-ra találták ki."!
-
alapz@j
tag
-
alapz@j
tag
-
alapz@j
tag
Sajnos nem működik úgy sem azért kezdtem el paraméterezni. Azonban ha hozzáadom a path environment variable-hez, akkor működik. Ez mitől van?
A codeblocks siman lefordítja azzal a paranccsal, hogy:Gcc main.c -o helloEgy sima hello world programot akarok lefordítani.
Másreszt azért mutat a bin-re mert a mingw install manager oda tette a dll fájlokat.
De ha csak egy sima Hello World programról van szó, ami önmagában lefodul, akkor miért kell még neked az a 4 dll?
-
alapz@j
tag
Hello.
Letöltöttem egy MinGW és szertnék lefordítani egy hello.c programot, azonban a compiler állandóan hibát dob, hogy hiányzik neki pár DLL. Már az összes cikket elolvastam és kipróbáltam de egyikkel sem ment. Továbbra is hiányzik neki. Az alábbi módon próbáltam fordítani:
gcc -c main.c -o test -LC:\Programming\Compiler\MinGW\bin -static -llibmingwex-0.dll -llibiconv-2.dll -llibgmp-10.dll -llibisl-15.dllA -c miatt csak fordít, de nem linkel, az -L paramétered a MinGW bin könyvtárára mutat a lib helyett, nem kell a -static kapcsoló, a dll-ekhez pedig nem kell a -l, simán írhatod, hogy "gcc ... main.c ilyen.dll olyan.dll"
-
alapz@j
tag
Gyakran jönnek ide (és nyilván más hasonló fórumokra is) olyan emberek, akik a tökéletesen nulla szintről (lásd: hová írjam a printf()-t) szeretnének megtanulni programozni és ezt úgy képzelik, hogy majd itt sorról sorra elmagyarázzák nekik a profik. Ez nem működik. Csak akkor tudunk segíteni, ha már legalább az olyan alapfogalmakkal tisztában vagy, mint forráskód, fordító, változó, stb. - és ezt nem lehet kérdezz-felelek formában elsajátítani.
Itt van egy teljesen kezdőknek készített C tutorial (environment setup, basic syntax, stb.), innen el tudsz indulni, és ha valahol elakadtál, biztosan lesz valaki ebben a topikban, aki segíteni fog:
A fenti oktatóanyagban az Environment Setup pontban részletesen leírja a telepítést, linkelve a mingw honlapját is.
-
alapz@j
tag
Gyakran jönnek ide (és nyilván más hasonló fórumokra is) olyan emberek, akik a tökéletesen nulla szintről (lásd: hová írjam a printf()-t) szeretnének megtanulni programozni és ezt úgy képzelik, hogy majd itt sorról sorra elmagyarázzák nekik a profik. Ez nem működik. Csak akkor tudunk segíteni, ha már legalább az olyan alapfogalmakkal tisztában vagy, mint forráskód, fordító, változó, stb. - és ezt nem lehet kérdezz-felelek formában elsajátítani.
Itt van egy teljesen kezdőknek készített C tutorial (environment setup, basic syntax, stb.), innen el tudsz indulni, és ha valahol elakadtál, biztosan lesz valaki ebben a topikban, aki segíteni fog:
-
alapz@j
tag
Emlékeim szerint a kompájlerrel egybecsomagolt CodeBlocks-ot nem kell tovább konfigurálni, hanem egyből érzékeli a mellé adott gcc-t.Biztosan jó volt a telepítésed?
Egybként a CB+GCC kombót nem feltétlenül ajánlanám olyan kezdőnek, aki Excel-be akarta írni a printf() -et.Ha Windows-on programozol akkor a PellesC vagy az MS Visual Studio barátibb környezetet biztosít.
-
alapz@j
tag
Vagy elolvasod ezt és lenyúlod a függvényeit. Mindenképpen utf-8-ként érdemes kezelni a szövegeket.
Már fentebb is linkelte valaki, de nekem több gondom is van ezzel a cikkel.
Egyrészt hibás nevezéktant használ, mert azt mondja, hogy van az UNICODE kódolás és az UTF8, holott az UTF8 az egy unicode kódolás.
Másrészt nincs olyan, hogy UNICODE kódolás - a cikk - pontos megnevezése nélkül - az UCS2-t mutatja be, illetve az UCS2-UTF8 konverziók egy részét.
Harmadrészt a cikkben szereplő függvények pont nem segítenek a kérdezőnek, mert neki az ASCII-UTF8 konverziókra van szüksége.
-
alapz@j
tag
Ok, de honnét tudom, hogy milyen bytesorozat kell nekem? Ilyet még nem csináltam korábban.
Kiolvasok 16 bitet/2 byte-ot és azt ellenőrzöm/hasonlítom?
Viszont ha a sima betűk meg csak 1 byte-ot foglalnak.
Esetleg kiolvasok 1 byte-ot, ellenőrzöm, hogyha van egyezés, akkor meg van a betű, hogyha nincs, akkor hozzá olvasom a következő byteot is és így hasonlítok?Fogsz egy text editor, beleírod, hogy áÁ éÉ ... az összes ékezetes magyar betűt, kimented UTF8 kódolással, megnyitod egy hex editorral és már meg is vannak a bájtsorozataid a karakterekhez. Ha jól emlékszem, az összes magyar ékezetes karakter kódpontja két bájtosra kódolódik UTF8-ban, ez könnyít a munkán. Ezután írsz egy függvényt, ami unsigned char-ként végigmegy a sztringed bájtjain - ha az adott char < 128, akkor hagyományos módon kisbetűsítesz, ha pedig >= 128, akkor a fenti bájtsorozatokat cseréled.
-
alapz@j
tag
Szerintem ne erőltesd a wchar-t, mert nagyon sötét erdőbe visz. Ha a bemeneti szövegeid sima ASCII kódolásúak, akkor a használt kódtábla szerint cserélgetheted a nagy- és kisbetűk bájtjait. Ha UTF8 kódolásúak, akkor írj egy olyan függvényt, ami nem csak egy bájtot, hanem egy bájtsorozatot cserél: pl. Á - d0 91 / á - d0 b1.
-
alapz@j
tag
Az egyik elv az, hogy csak akkor valtoztatnak meg szabalyokat/mintakat, amikor arra kifejezetten jo ok van. Tehat ha idaig jo volt az ANSI, es az ujabb feladatokat is meg lehet oldani igy, akkor nem tesznek a fejlesztokre extra mentalis terhet azzal, hogy varialnak.
A C++ (Scala, etc.) egyik fo problemaja, hogy nagyon sok modszerrel meg lehet csinalni ugyanazt. C++-ban irhatsz proceduralis, OO, funkcionalis, etc. programot, ami egyreszt meno+kenyelmes, masreszt sokkal nehezebb megakadalyozni, hogy egy nagyobb projektnel divergaljon a stilus/megkozelitest. A sokfele megkozelites meg azt eredmenyezi, hogy a projekt reszvevoinek 1) allandoan el kell donteni, hogy melyiket alkalmazzak 2) nehezebb ertelmezni a masik kodjat.
Pl. a Java ezert is olyan sikeres -- egy Java kodot _barki_ el tud olvasni. (Ott a komplexitast attoltak a frameworkok szintjere.)
Értem, de azért azt tegyük hozzá, hogy az általa említett Javában is gyakran van szintaktikai változás verziók között - ha jól emlékszem, pl. az 1.5-től jött be a
for (String s : stringArray)forma a korábban használtfor (int i ...) stringArray.get(i)kiváltására és nem okozott ez törést senki életében. -
alapz@j
tag
-
alapz@j
tag
Viszont ha már szóba jött a
continueakkor megkérdezem, hogy mit gondoltok areturnkifejezés többszöri felhasználásáról egy függvényen belül? Sokan ezt is elítélik, de én előszeretettel térek vissza hibát jelző értékkel argumentum ellenőrzés után kivételkezelést nem támogató függvények esetén.A "no push friday" mozgalmat pedig támogatom
Mennyivel nyugisabb lenne az utolsó munkanap.maestro87 Így már
jobbanjól hangzik, hajrá-hajrá!
Szerintem nincs gond se a goto-val, se a continue-val, se a többszörös return-al. Van aki még a for (int i = 0... -t se tudja elfogadni, mert a C csak ANSI C-lehet, föggvényközbeni deklaráció nélkül. Én meg azt mondom, hogy whatever floats your boat, man...
-
alapz@j
tag
Ha már optimalizálunk, akkor csináljuk rendesen:
switch(c)
{
case 'a':
case 'e:
case 'i':
case 'o':
case 'u':
case 'A':
case 'E:
case 'I':
case 'O':
case 'U':
return 1;
default:
return 0;
}vagy ha van valakinek türelme egy 256 elemű tömböt teleírni egyesekkel meg nullákkal:
return maganhangzok[ c ];
Na, a babakódom

#include <string.h>
char maganhangzok[] = "aeiouAEIOU";
char betuk[256];
void setup_betuk(void) {
memset(betuk, 0, 256);
size_t len = strlen(maganhangzok);
for (size_t x = 0; x < len; ++x) betuk[maganhangzok[x]] = 1;
}
inline char maganhangzo_e(char x) {
return betuk[x];
} -
alapz@j
tag
Ha már optimalizálunk, akkor csináljuk rendesen:
switch(c)
{
case 'a':
case 'e:
case 'i':
case 'o':
case 'u':
case 'A':
case 'E:
case 'I':
case 'O':
case 'U':
return 1;
default:
return 0;
}vagy ha van valakinek türelme egy 256 elemű tömböt teleírni egyesekkel meg nullákkal:
return maganhangzok[ c ];
Nem kell kézzel megcsinálni, memset-eled nullával a betuk[256]-ot aztán egy ciklussal a magánhangzók ascii értékeinek megfelelő bájtokba egyeseket írsz

-
alapz@j
tag
Írjsz egy függvényt, ami megmondja egy char-ról, hogy magánhangzó-e:
#include <ctype.h>
#include <stdio.h>
static char * maganhangzok = "aeiou";
int maganhangzo(char c)
{
int i = 0;
for(; i < strlen(maganhangzok); ++i)
{
if(maganhangzok[i] == tolower(c)) return 1;
}
return 0;
}Ha ez megvan, akkor az eredeti tömbbön végigfutsz ezzel, és megnézed, hogy mennyi magánhangzód van.
Ezt követően azt szétszeded két tömbre, amit aztán használsz.
Utána pedig a feltöltésnél karbantartasz két indexet, és azokat lépteted annak függvényében, hogy a ciklusváltozód páros vagy páratlan.int i=0;
int msh_idx = 0;
int mgh_idx = 0;
for(;i<celtomb_hossza -1 ; ++i)
{
if(i%2 == 0)
{
celtomb[i] = msh_tomb[msh_idx];
msh_idx = (msh_idx + 1) % msh_tomb_hossza; //strlen?
}
else
{
celtomb[i] = mgh_tomb[mgh_idx];
mgh_idx = (mgh_idx + 1) % mgh_tomb_hossza; //strlen?
}
}
//lezaro nulla ne maradjon le! :)for(size_t i = 0; i < strlen(maganhangzok); ++i)
Ezt a formát azért nem ajánlanám, mert minden egyes iterációban kiértékeli az strlen()-t, ami eléggé lelassítja a működést.
-
alapz@j
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.
Nincsenek megadva a textúra-koordináták.
-
alapz@j
tag
Van valamilyen oka annak, hogy GLUT-ot használnál ablakkezelésre? Jobban járnál valamivel ebből az évtizedből (évszázadból?): GLFW, SDL2, stb. Plusz nem hiszem, hogy az IDE bármivel is segítene OpenGL programozásban...
-
alapz@j
tag
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.
PellesC, MinGW, Tcc, ezek mind működnek. MinGW-ből én a http://nuwen.net/mingw.html -t használom.
-
alapz@j
tag
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
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...
-
alapz@j
tag
Hát így

Én nem kaptam oktatást minden amit tudok azt magamnak és nem a fizetett egyetemnek köszönhetem..
nem sok, de kérdezni tudok és ti remélhetőleg segítetek annak aki nem tud valamit.
Biztos én is tudnék példát felhozni arra, hogy te mit és miért csinálsz, ha ezt vagy azt nem tudod...
Mindig érdemes magadból kiindulni mielőtt kritizálsz.
Nem születik az ember programozónak, úgy tanulja meg, hogy megmondják neki.
Amúgy eljutottam odáig, hogy byte-onként olvasom be a fájlt egy tömbbe és azt íratom ki..
Szépen lassan megírom egyedül is a programot.Én jogász vagyok, bro - minden, amit tudok, azt saját magam tanultam önszorgalomból. És ezzel az égvilágon semmi baj nincs - csak azt nem értem, hogy a programozáshoz vezető úton hogy maradhatnak ki valakinél ezek a legalapvetőbb építőkövei a technológiának.
-
alapz@j
tag
Hogy programozhat úgy valaki, hogy nem érti a szöveges és a binary fájl közötti különbséget?
-
alapz@j
tag
Írj egy one time pad alkalmazást. Egy hex és base64 kódolót/dekódolót. Aztán valami egyszerűbb ciphert (pl. rot13) használó kis programot. Aztán írj egy programot, amiben egy külső titkosító könyvtár (wincrypto, libnettle, openssl, akármi) egyszerű szimmetrikus titkosítását használod (xxtea, aes, chacha, stb.). Közben ismerkedj meg a secure random, a kriptográfiai hash, a keyed hash fogalmával és használatával. Ezután jöhet az authenticated titkosítás, a nyilvános kulcsú kriptográfia és a többi finomság. És mindeközben sajátítsd el azt, hogyan lehet biztonságos C programot írni, amelyik nem szivárogtat ki információkat az általa kezelt adatokról.
-
alapz@j
tag
Sziasztok!
Kaptam még jó pár hónapja egy RAR fájlt, ami tele van hasznos dolgokkal, de sajnos jelszóval védett, amire nem emlékszem. Akitől kaptam, nyilván tudja és meg tudnám kérdezni, DE én arra gondoltam, hogy írni kellene egy C programot (nem letölteni egy már kész szoftvert), ami megfejti nekem a jelszót. Érdekel az IT biztonság, a vírusok, a vírusok elleni védekezés, az "ethical hacking", viszont totál zöldfülű vagyok ezen a téren, még soha nem foglalkoztam ilyesmivel. Valakinek van ötlete, hogyan lehetne belekezdeni egy efféle program megírásába? Akár együtt is elkészíthetnénk, soha nem dolgoztam még csapatban, jó lenne tapasztalatot szerezni ilyen téren is.
A kihívásoktól nem riadok vissza, az idő pedig nem sürget, tehát ha csak hétvégente foglalkozunk vele néhány órát, az sem akadály!
Köszi előre is a válaszokat, üdv!
Ez a probléma bonyolultabb annál, sem hogy egy szabad hétvégéden nekiállj megoldani. Ha érdekel a titkosítás, mint programozási terület, ennél egyszerűbb dologgal kezdj szerintem.
-
alapz@j
tag
Te, ez most komoly? Eddig programoztál egy nyelven, amiről nem is tudtak, hogy micsoda? Vagy lemaradtam valamiről?
-
alapz@j
tag
Nem teljesen értem a problémát - az ascii karaktereket tartalmazó stringed az önmagában egy tömb, ami 0xXX értékeket tartalmaz...
-
alapz@j
tag
Csak tippelem, hogy 4 byte lesz a sizeof, mert bár kevesebbe is beleférne a 10 bit, de mintha 32 bites rendszeren ez alá nem paddingolna.
-
alapz@j
tag
#include <stdio.h>
void main() {
if(puts("Hello World")) {}
} -
alapz@j
tag
Banális kérdés, de valahogy nem egyértelmű számomra: a wide char-okból álló string lezárója a 0x0000?
-
alapz@j
tag
-
alapz@j
tag
Valaki kijavít, ha tévednék, de szerintem sima getch() (már) nincs. Van a conio.h-s _getch() és van a stdio.h-s getchar().
-
alapz@j
tag
Ezt a megoldást (ch= _getch();) a neten találtam.
Valaki el tudná magyarázni, hogy miért működik ez, mit befolyásol a _ a függvény neve előtt?
Nem befolyásol semmit, ez a függvény neve:
#include <conio.h>
int _getch( void );
wint_t _getwch( void ); -
alapz@j
tag
Hat, amint nem magadnak hanem csapatban es/vagy kesobb atadassal dolgozol, ezek a szep megoldasok adjak a karbantarthatatlansagot. Persze jo neked, ha ezzel akarsz kikerulhetetlen lenni a cegnel, de me'g akkor is, mielott azza valnal, velhetoleg egy projvez eszreveszi.
[Az meg hogy lenne mar logikus matematikailag, hogy az 1 a paros jele, 2 a paratlane???]
Persze nem arrol van szo, hogy ezt a ket sort nem kutya kotelessege barmely programozonak megfejteni tudni, hanem arrol, hogy ezt a stilust ha kicsit is nagyobb meretben is megtartod, akkor jon az hogy jol mukodik de egy rossz kod. Es most arrol nem is beszeltunk, hogy beszedesebb konstansoknal kisebb az osszekeveresi lehetoseg (ha meg hiba soran - pl. atkuldod masik gepre - modosulhat is, akkor nem art ne'mi Hamming-tavolsag, nalunk a C-sek kod.szab.-aban benne van hogy minden konstansra azt is alkalmazni kell).
Java-ban meg irtam en mar prog.verseny feladatokat is, egy darab main-nel, nem csak objektum-hegyek eseten alkalmazhato
[jo hat nem volt idealis valasztas, de abban voltam a leggyakorlottabb, es kezrealloan telepitett kornyezet is ahhoz volt].Nem azt mondtam, hogy logikus, hanem hogy párhuzamban van, mert az eredmény branching helyett egy egyszerű számítással következik a bemenetből. Egyébként igazad van a karbantarthatósággal kapcsolatban, production környezetben nyilván mások az elvárások.
-
alapz@j
tag
Nem is a ternary a problemas nekem (bar egyes kodolasi szabvanyok tiltjak), hanem az hogy kihasznalod az osszefuggest. Ha ezt irtad volna tomoritesnek:
return a == 0 ? 0 :
a%2==0 ? 1 : 2;
akkor nem szoltam volna, mert tomor, pont ugyanaz mint az if-ek, es barmikor az egeszek kicserelhetoek. Persze meg jobb lenne kulon definialni a konstansokat, es utana
return a == 0 ? RESULT_0 :
a%2==0 ? RESULT_EVEN : RESULT_ODD;Persze szubjektív, de számomra a C éppen az ehhez hasonló okos, elegáns, tömör és hatékony megoldásokat jelenti, aminek része az interfész átgondolt felépítése is. Az e() fgv. éppen azért tud ilyen jól működni, mert az általa visszaadott értékek párhuzamban vannak a megoldás matematikai összefüggéseivel.
Ha Javában írnám, tuti én is meghívnék benne 5 Factory-t, 3 Managert-t és 4 Providert, miközben Hibernate-el pakolnám relációs adatbázisba a közben keletkező objektumok százait

-
alapz@j
tag
-
alapz@j
tag
Ma reggel eszembe jutott még egy tömörítési lehetőség, de már csak haladóknak

int e(unsigned int a) {
return a == 0 ? 0 : (a % 2) + 1;
} -
alapz@j
tag
Ha elfogadsz még egy tanácsot: próbálj meg átláthatóbb forrást írni, mert hosszabb programnál el fogsz veszni a kapcsos zárójelekben

#include<stdio.h>
int e(int a) {
if (a == 0) return 0;
return (a % 2) + 1;
}
int main() {
int a;
printf("Adj meg egy szamot: \n");
scanf("%d", &a);
switch (e(a)) {
case 1:
printf("A szam paros\n");
break;
case 2:
printf("A szam paratlan\n");
break;
case 0:
printf("A szam nulla\n");
break;
}
return 0;
}Vagy még jobb:
#include <stdio.h>
int e(int a) {
if (a == 0) return 0;
return (a % 2) + 1;
}
int main() {
char *types[] = {"nulla", "paros", "paratlan"};
int a;
printf("Adj meg egy szamot: \n");
scanf("%d", &a);
printf("A szam %s\n", types[e(a)]);
return 0;
} -
alapz@j
tag
Köszönöm ez nagy segítség volt!

Most már kicsit tisztább is lett a kép közben.
Így gondoltad ugye?
#include<stdio.h>
int e(int a)
{
if (a==0)
{
return 0;
} else if (a%2==0)
{
return 1;
} else { return 2;
}
}
int main()
{
int a;
printf("Adj meg egy szamot: \n");
scanf("%d", &a);
if (e(a)==1)
{
printf("A szam paros\n");
} else if (e(a)==2)
{
printf("A szam paratlan\n");
}else
{
printf("A szam nulla\n");
}
return 0;
}Ha elfogadsz még egy tanácsot: próbálj meg átláthatóbb forrást írni, mert hosszabb programnál el fogsz veszni a kapcsos zárójelekben

#include<stdio.h>
int e(int a) {
if (a == 0) return 0;
return (a % 2) + 1;
}
int main() {
int a;
printf("Adj meg egy szamot: \n");
scanf("%d", &a);
switch (e(a)) {
case 1:
printf("A szam paros\n");
break;
case 2:
printf("A szam paratlan\n");
break;
case 0:
printf("A szam nulla\n");
break;
}
return 0;
} -
alapz@j
tag
Azert nem ilyen egyszeru mert nem tudom elore a szamokat darabszamat.
Az en megoldasom is forral es iffel mukodik:
http://baratiistok3.square7.ch/functions/str.c
Jól megbonyolítottad a dupla tömbökkel

char string[] ="1 22 333 444 5555";
char *pch = strtok(string," ");
while (pch != NULL) {
printf("%i\n", atoi(pch));
pch = strtok(NULL, " ");
}vagy ha már belelendültem:
char *string = "1 22 333 4444 5555";
size_t i = strlen(string);
while (--i) if (string[i] == ' ') printf("%i\n", atoi(string + i));ez utóbbi jobb is, mert a strtok-al ellentétben nem módosítja a stringedet.
-
alapz@j
tag
char *string = "2 31 457";
int i1, i2, i3;
sscanf(string, "%d %d %d", &i1, &i2, &i3); -
alapz@j
tag
Sziasztok!
Szeretnék némi segítséget kérni tőletek bináris fájlból való olvasáshoz. Találtam egy feladatot nemrégiben ami megfogott, mert nem tudok rájönni a megoldásra. Így szól:
"Olvassa be egy 'h.bin' nevű bináris fájlból a long int h[6]; tömböt, 6*sizeof(long int) méretben!"Odáig eljutottam, hogy ha minden igaz akkor fread() függvényt kell használni az eljáráshoz, viszont nem teljesen értem a függvény működését és magát a feladatnak se azt a részét, hogy egy bináris fájlból hogy olvassak be egy tömböt.
Ha valaki tudna adni bővebb magyarázatot, vagy a témához szorosan kapcsolódó anyagot azt megköszönném.
FILE *f = fopen("h.bin", "rb");
long int h[6];
fread(h, sizeof(long int), 6, f);
fclose(f); -
alapz@j
tag
A billentyűzet pufferbe bennmarad egy enter és azt olvassa ki a scanf a %c-re
Ezt úgy lehet kezelni, hogy a scanf-nek megadod az elválasztó karakter, amit a beolvasáskor elnyel.
Az elválasztó karakter ez esetben a \r.Érdemes kiíratni hoyg mit is olvasott be, így hamar kiderülnek a hasonló hibák.
Javítsd ki így a scanf-es sort:
scanf("%d\r%d\r%c",&a,&b,&c);
így nekem működött linux alatt. a scanf_s nem ansi C szabvány, hanem a microsoftnak a találmánya, azzal nem tudom kipróbálni.
A scanf_s konkrétan a C11, azaz a szabványos C része, ha nem működik linux alatt, az a gcc problémája lesz...
-
alapz@j
tag
Már megbocsáss, de te nem a problémát oldottad meg, hanem a compilert sikerült rávenned arra, hogy szemet hunyjon a hibád felett. Mi akadálya volt annak, hogy a szájbarágós magyarázatnak megfelelően a scanf_s függvényt használd a scanf helyett? És akkor egy csapásra egy buffer overflow lehetőséget is kiküszöböltél volna...
char c;
scanf_s("%c", &c, 1); -
alapz@j
tag
Igen,le is tudtam futtatni és működött csak én igazából arra vagyok kíváncsi,hogy amit megírtam programot azt összetudom "kovácsolni" egy ablakkal (nehéz elmondani mire gondolok
) vagy külön kell megírnom,bonyolult elmagyaráznom de hát a programozás is bonyolult,és ez fogott meg benne! 
Az előző hozzászólónak köszönöm a segítséget mindenféleképpen utána nézek
pl.
#include <stdio.h>
void main ()
{
printf("Hello World!\n");
}
Most leirtam a világ legegyszerűbb programját,és igazából azzal nem vagyok én kibékülve,hogy ha ablakot akarok neki késziteni akkor ezt a programot másképp kell leírnom,más szintaxis szerint vagy ezt valahogy belehet helyezni?!
C-ben is könnyedén lehet GUI-t programozni, akár közvetlenül a Win32 API-t akár valamelyik multiplatform toolkitet, mint a GTK vagy az egyébként általam is használt és imádott IUP. Ettől függetlenül én is a Java Swinget vagy a .Net-et ajánlanám kezdő programozónak, mert azok eleve adottak a Java és a .Net környezetekben, nem kell dll-ekkel vagy statikus programkönyvtárakkal bajlódni.
A kérdésedre egyébként az a válasz, hogy az ablakot a megfelelő függvényhívásokkal hozod létre (kovácsolod a programodhoz): pl. win32 API-val
...
int mydialog = DialogBox(hInstance, MAKEINTRESOURCE(DLG_MYDLG), NULL, (DLGPROC)MyDlgProc);IUP-al:
Ihandle *dlg;
...
IupShow(dlg);stb., stb.
Ja, és egy jó tanács: ne keverjétek a C-t és a C++ -t, még nevükben sem

-
alapz@j
tag
Sziasztok,új vagyok még a programozásba még csakkonzol applikációt írtam és valamelyik nap nézegettem a c++-t és megtaláltam ez a WindowsFormsApplication-t megjelent egz ablak amit saját ízlésem szerint testre tudtam szabni.A kérdésem a következő,lehetséges olyan hogy ami konzolba megy program,azt úgy megoldani,hogy egy önnáló "program" legyen?! Tehát ablakja legyen ne a konzol nyitódjon meg és gyakorlatilag egy önnáló program legyen? Vagy ez,hogy lehetséges megoldani?Tudom nem egyszerű de legalább valami nekifutó kellene.Az olyan kommenteket kerülném,hogy "rossz pályát választottál" mert szerintem senki sem született programozónak.Köszönöm.
Nem egészen értem a problémát: ha a Visual Studio-ban (legalábbis gondolom, hogy ez, a sablon-név alapján) a "WindowsFormsApplication" varázsló kitett neked egy ablakot, amit saját ízlésed szerint testre tudtál szabni, akkor lényegében "írtál" egy GUI-val rendelkező programot, nem? Build solution aztán run.
-
alapz@j
tag
Köszönöm, megpróbálom akkor ezek szerint.
Még egy kérdés: ha normálisan akar C-ben programozni az ember, akkor milyen programot érdemes használni? Eddig a notepad -> notepad++ -> Eclipse+Cygwin utat jártam be, de mindegyiknek megvoltak a maga bajai. Van olyan keretrendszer, ami különösen ajánlott, vagy bármelyik jó, csak szokjak hozzá a sajátosságaihoz?
A NotePad++ és a Cygwin alapján feltételezem, hogy Windows OS alatt programozol - ebben az esetben a legújabb Microsoft Visual C Express-t vagy a PellesC-t ajánlanám, mindkettő ingyenes és nagyon jó fejlesztői közeg, ez utóbbi teljesen C11 konform és a resource editor is teljes benne (pl. van dialog builder, ami az msvce-ből pl. hiányzik).
-
alapz@j
tag
Viszont végre jól működik a program, mert az 'á' megjelent - még ha helytelen kódolással is - a feldolgozott sztringben
Egyébként ebből is látszik, hogy ez inkább konzol (terminál) probléma, mert a default 852 kódlappal ugyanaz az exe nálam is megeszi a szó eleji á-t. -
alapz@j
tag
-
alapz@j
tag
Nálam is tökéletes volt, egy kivétellel: ha á-val kezdődött a szó, akkor azt levágta. Viszont ha belül volt az á, akkor nem bántotta.

-
alapz@j
tag
Alap problémám akadt. Ékezetes karaktereket szeretnék bevinni és kiírni. Az alábbi leegyszerűsített kódal próbáltam, de az 'á' betűvel kezdődő szavakból lemarad az első betű. pl. állomás -> llomás. Az 'ékezet' szót kiírja hiba nélkül. Mit szúrok el?
#include <wchar.h>
int main()
{
wchar_t string [40];
wscanf(L"%ls",string);
wprintf(L"String: %ls", string);
return 0;
}Érdekes, gcc-vel és tcc-vel is lefodítottam a programodat és mindkét esetben tökéletesen működik az érzékeny karakterekre (űőŰő) is...
-
alapz@j
tag
Szerintetek mi az oka annak, hogy a string.h függvényei char* paramétereket fogadnak és char* értékeket adnak vissza unsigned char* helyett, ami - szerintem - a logikus lenne?
-
alapz@j
tag
Na, megint jövök a kérdéseimmel
Csinálgatok most egy kis programot, amihez több, külső forrásból való kódot használok fel. Olvasgattam a hozzájuk tartozó header fájlokat, és feltűnt, hogy olyan definíciók vannak a fájlok elején, hogy(aes.h)
#ifndef AES_H
#define AES_H
...
#endif(sha256.h)
#ifndef SHA256_H
#define SHA256_H
...
#endifstb. Ezeknek pontosan mi a célja és értelme?
-
alapz@j
tag
A Stack Overflow-n egy ilyen C forrást láttam:
int main() {
@valami {
int x...
}
}A @valami micsoda? Soha nem találkoztam még ilyennel korábban.
-
alapz@j
tag
Majd elfelejtettem.
Előre bocsátom, hogy ez az egyik legszemetebb teszt kérdés a C-ben. Ugyanis ehhez jól kell ismerni a C szabványt, mert abban van leírva, hogy "két szekvencia pont között ha egy változónak egynél többször adunk értéket, akkor nem definiált a működés", azaz nem tudjuk biztosra megmondani, hogy mi lesz az eredmény, mert fordító függő lesz.
Ismerősöm állás interjún kapott egy ilyen feladatot, de volt ám meglepetés, amikor elkezdte mondani a fentebbi szöveget, ugyanis az interjúztató nem tudott erről
. Így nem kell bánkódni azoknak akik nem tudták. Egy évvel ezelőtt én se tudtam volna a helyes választ.Nálam hiányzik a C ilyentén elméleti megalapozása, ezért megkérdezem: mi az a szekvencia-pont?
-
alapz@j
tag
Köszönöm, közben én is megtaláltam a megoldást a neten, de nem akartam a kérdést kitörölni, hogy maradjon itt is nyoma. A %i-nek van egy ilyen meglepő tulajdonsága, hogy 0-val kezdődő stringek esetén oktális, 0x -el kezdődőknél pedig hexa értelmezést csinál.
-
alapz@j
tag
Egy érdekes problémába botlottam, ami három különböző fordítóval is előjön, szóval a kódban lehet a hiba, de nem tudom, hogy mi.
#include <stdio.h>
int main(void) {
char date[] = "2014/05/01";
int year, mon, day;
int res = sscanf(date, "%i/%i/%i", &year, &mon, &day);
printf("%i\n", res);
return 0;
}Ez így jól működik, a res-be három kerül, mert három értéket sikerült beolvasnia a sscanf-nak. De ha a hónapot átírom 08 vagy 09-re akkor azt már nem ismeri fel. Minden más értékre működik. Ha sima 8-at vagy 9-et írok, megint működik. Szerintetek?
-
alapz@j
tag
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.Azért konstruktor, mert megkonstruálja a String-et

-
alapz@j
tag
Miről van szó amúgy? ARM-nál szintek vannak meghatározva, ahol a supervisor mindent megtehet, de ha egy user szintű akar oda írni, ahova nem lenne szabad, akkor ezt hard fault expection-nel köszöni meg a proci. Azaz itt az architektúra tartatja be a szabályokat. Továbbá az MPU-nak meg lehet mondani, hogy ki hova írhat, de az megint egy másik tészta.
Nem mellesleg a C standard nem beszél ilyenről, így ilyen nincs. Az, hogy az OS vagy az architektúra támogatja-e az már a C-n kívül álló dolog.
Van egy string könyvtáram, ahol a String típus egy struktúra, amiben egy char* változó mutat a tényleges karaktersorozatra. Hogy a felhasználónak ne kelljen még plusz a memóriakezeléssel is bajlódnia, a sztringek mutable-ként működnek, úgy, hogy a függvények új memóriaterületet allokálnak az eredménynek, a régi területet pedig felszabadítják free-vel Ez ugye a felhasználó számára nem látszik, mert ő mindig ugyanazt a String változót látja. A konstruktor függvény első verziója egyszerűen felvette a felhasználó által megadott char* értéket. Ez viszont nem jó, mert ha a stack-en van a karaktersorozat (és nem static), akkor ugye az megsemmisül, ha char* x = "x" formában definiált volt, akkor az r/o memóriaterületen van és az első free-nél kiakad a rendszer, stb. Úgyhogy a jelenlegi konstruktor duplikálja a karaktersort a heap-re, ami csak annyiban rossz, hogy ha már eredetileg is ott volt, akkor kétszer annyi memóriát használ a program. Az lenne a legelegánsabb megoldás, ha a konstruktor érzékelné, hogy a paraméter a stack-re, r/o területre vagy a heap-re mutat és ennek megfelelő memóriafoglalási stratégiát választana.
-
alapz@j
tag
Oké, de az alapprobléma épp az volt, hogy hogyan lehet eldönteni, hogy egy string ro vagy rw memóriaterületen van? Mert ha ez megvan, már nem jelent gondot a különböző kezelésük.
-
alapz@j
tag
-
alapz@j
tag
Van arra mód, hogy egy függvény a paraméterként kapott char* pointerről eldöntse, hogy az read-only, read-write memóriaterületre vagy a heap-re mutat?
-
alapz@j
tag
Köszi, de mikrokontrollerbe használom így azt hiszem vagy is azt gondolom, hogy nem működne ez ebben a formában.
Főként talán azért mert nem emlékszem, hogy a C18-as könyvtárban lenne ilyen "intrin.h" állomány.Egyébként ha működne miért lenne ez jobb mint az előző?
A tömbökben amiket törlök memset()-el rövid életűek és csak az interfészen bevitt karaktereket tárolják majd ha végeztem a 14 adat bekérésével kimentem memóriába a tömb adatait és utána rögtön törlöm is.Tényleg ha már itt tartok:
Hogy tudom ellenőrizni a tömb tartalmát hogy abban karaktert vagy számot írtam?
Mutatok egy példát:unsigned char teszt[4] = {'1','2','3','\0'};
//ellenőrzés pedig
if(atoi(teszt)>0 & atoi(teszt)<255){
printf("Csak szám\n");
}else{
printf("Nem csak szám\n");
}
//Másik változat
unsigned char teszt[4] = {'1','1','A','\0'};
//ellenőrzés pedig
if(atoi(teszt)>0 & atoi(teszt)<255){
printf("Csak szám\n");
}else{
printf("Nem csak szám\n");
}Eredménye:
1. Csak szám - ez helyesen értékelődik ki
2. Csak szám - ez hibásan értékelődik ki mivel tartalmaz egy betűt isTegnap próbálkoztam vele és pl: ha betűvel kezdődik a tömb akkor helyesen értékelődik ki, de ha az elején szám van és a végére betűt írok akkor hibás a kiértékelődés.
Hogyan tudom megvizsgálni a tömböt, hogy abban csak számok van?
Köszi előre is..ui: tömb bejárásnál eszembe jutott, hogy talán elemnkénti vizsgálattal pl:
if(tomb[i] != 'A - Z' & tomb[i] != 'a - z') //helyes
Vagy valami ilyesmi...
Nem mondtam, hogy jobb lenne, csak egy megoldás, amibe tegnap futottam bele. Egyébként lehet hogy a memset is ilyen megoldást használ.
-
alapz@j
tag
Hölgyek, Urak!
Hogy tudok egyszerűen és gyorsan törölni egy tömböt?
Pl. van egy ilyen tömböm:
tomb[] = {a,b,c,d,e,f,1,2,3};
Szeretném ennek teljes tartamát törölni, de lehetőleg nem bejárással.
Van erre valami jól bevált vagy legalább hatékonyan használható parancs vagy kód?
Köszi előre is..Pont tegnap próbáltam ki az alábbi kis szösszenetet, ami válasz a kérdésedre is:
#include <stdlib.h>
#include <intrin.h>
int main(void) {
unsigned char *test = (unsigned char*)malloc(100);
__stosb(test, 0, 100);
free(test);
return 0;
}X86 és X64 architektúrákra.
-
alapz@j
tag
-
alapz@j
tag
Szeretném én is kiegészíttetni a téma összefoglalót.
Magyar nyelvű könyvekhez:
Kónya László-Kopják József - PIC Mikrovezérlők alkalmazástechnikája [link]Fejlesztő környezetek:
Clang
cross-platform (Windows / Linux / OSX) csak fordítóMPLABX
cross-platform (PIC) fejlesztőkörnyezetEclipse CDT
fordítót nem tartalmaz, de konfigurálhatósága miatt szinte minden platforma minden fordítóval lehet benne fejleszteniLPCXpresso
cross-platform (NXP Cortex-M, ARM7, és ARM9 alapú mikrokontrollerek) fejlesztőkörnyezetAtmel Studio
cross-platform (AVR8, AVR32, Atmel ARM-ok) fejlesztő környezetarm-none-eabi
cross-platform (ARM Cortex-M és Cortex-R) csak fordítóEzek mind ingyenesen használhatóak. Az MPLABX-ben nem vagyok biztos.
A Mingw-mellé esetleg mehetne a Mingw-w64, ami 32 és 64 bites környezetet is ad: [link]
-
alapz@j
tag
Fél szemmel figyelemmel követem az OpenBSD-s srácok OpenSSL újraíró projektjét (LibreSSL) és annak kommentárjait a Opensslrampage.org -on. Az egyik legutóbbi gyöngyszemük az OpenSSL kódból:
strncpy(dest, src, strlen(src))
Ez azért komoly kérdéseket vet fel a kód minőségét illetően...
-
alapz@j
tag
-
alapz@j
tag
Ez ebben a formában még magas nekem, de azért köszi a szándékot.
A mutatókat már ismerem, de csak felületesen.
Átvariáltam a dolgot mivel a fentebbi kódomnál csak a char típus jöhetett szóba és így pazaroltam a bájtokat illetve a megfelelő típusmódosítások is igényeltek további sorokat.
Az új verzában már külön szedtem a char és int típusokat és így már szebben lehet e memóriába beírni és kiolvasni.
Nem kellenek az elválasztó karakterek sem.
Ahogy tanulom és gyakorlom a dolgot úgy értem meg egyre jobban a működéseket.
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
Véletlenszám generátor inicializálásához szükségem lenne (legalább) 128 bit adathoz (seed). Szívesen fogadnék bármiféle ötletet a szokásos rendszeridő, process id, stb. megoldásokon túl.
A Random.org atmoszférikus zajból készít véletlenszámokat, amelyek publikus API-n keresztül elérhetőek. Ez a link pl.
http://www.random.org/cgi-bin/randbyte?nbytes=16&format=h
128 bit valódi random számot ad hexában (az url paraméterek magukért beszélnek).
-
alapz@j
tag
Közben meg is oldottam a dolgot.
A kérdésem a következő lenne:
Van esetleg egyszerűbb és hatékonyabb megoldás a következő kódomra?
#define MAXTOMBSIZE 32 //headerbe
//main()
unsigned int maxmemtomb;
char meminput[MAXTOMBSIZE] = "Valaminev#60#120#185#225#240#260";
char memtomb[7][46];
int i,z,x;
char ek = '#';
maxmemtomb = MAXTOMBSIZE;
x=0;
z=0;
for(i=0; i<=maxmemtomb-1; i++){
if(meminput[i] == ek){
z=0;
x++;
printf("\n%c", meminput[i+1]);
memtomb[x][z] = meminput[i+1];
z++;
i++;
}else{
printf("%c", meminput[i]);
memtomb[x][z] = meminput[i];
z++;
}
}
printf("\n\nTömbbe rendezve:\n");
for(i=0; i<=6; i++){
printf("%i. adat: %s\n",i, memtomb[i]);
}
Illetve az is érdekel, hogy miért kellett a "char memtomb[7][46];" többdimenziós tömböm második paraméterébe minimum 46-ot tennem, hogy jó eredményt kapjak?
Ezt nem értem még akkor sem, ha így működik...
Elviekben ott a maximum 9 karakter lehet mert a "Valaminev" a leghosszabb string nem? Vagy nem jól értelmezek valamit?> Van esetleg egyszerűbb és hatékonyabb megoldás a következő kódomra?
Ha az eredeti meminput tömbre nincs szükséged, akkor hatékonyabb, ha a kettőskereszteket kicseréled 0 értékekre és az azokat követő karakterre mutató pointereket tárolod el egy char *[]-ban. -
alapz@j
tag
Esküszöm nem keresem a c vs. java példákat, de most megint belefutottam egybe: http://raspberrycompote.blogspot.ie/2014/03/programming-language-micro-benchmark.html
A platform RasPi (arm), a feladat prímkeresés. -
alapz@j
tag
A korábbi c vs. java témához engedjetek meg egy linket még: https://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster-than-an-unsorted-array/11227902#11227902
Különös figyelemmel erre e részre: Intel Compiler 11 does something miraculous. It interchanges the two loops, thereby hoisting the unpredictable branch to the outer loop. So not only is it immune the mispredictions, it is also twice as fast as whatever VC++ and GCC can generate! In other words, ICC took advantage of the test-loop to defeat the benchmark... Szóval a konkrét gépi kódtól függetlenül is lehet jelentős sebességnövekedést elérni az adatok ügyes szervezésével.
Érdemes még a további kommenteket is elolvasni, pl. hogy a ternary operator-t mennyivel jobban fordítja a gcc, mint a sima if-then feltételes elágazást.
-
alapz@j
tag
PC-n máshogy jön ki a dolog, de azért ne általánosítsunk. Qt-ban olyan kódot írhatsz ami GUI-t kezel és ugyanaz a függvény hívás három oprendszeren is működik. Csak külön le kell fordítani mind a háromra. Viszont beágyazott rendszerben nagyon kényelmes tud lenni, hogy PC-n kezdem el a fejlesztést, ahol ugye egyszerűbb debuggolni a C kódot és a memóriá elírásokat is nagyság rendekkel könnyebb megtalálni. Közre játszik ugye az is, hogy az elírásról az IC nem dob fel neked egy ablakot, hogy hoppá
. Amikor az ember túl van a nehezén csak áthúzza a másik projektbe és mehet a fejlesztés tovább a hardveren mindenféle változtatás nélkül. Ez a platform függetlenség. Persze ehhez mindkét helyen meg kell lennie a megfelelő interfész függvényeknek.Vuze-val kapcsolatban rosszul emlékeztem akkor, de ettől függetlenül panaszkodnak rá, hogy jobban eszi a gépet, mint a többi torrent kliens.
(#4421) alapz@j: Szó mi szó nem szaggat nálam se, de a ventit nagyon pörgeti az fix.
(#4420) dabadab: C a beágyazott rendszerek egyeduralkodó nyelve. Ha újabb kocsid van, akkor nagyjából 10 millió sornyi C kód vigyáz rád, illetve szórakoztat téged
. Én személy szerint nem tanultam mást csak C-t. Ön szorgalomból tanultam meg a PERL-t, C++-t, egy kicsit a bash-t.(#4437) alapz@j: Hogy a fenébe van ideje futás közben újra fordítani? Pontosítok. Honnan tudja futás közben, hogy hogyan lehet optimalizáltabb? Hogy tud még ennél is optimalizáltabb kódot fordítani?
> Hogy a fenébe van ideje futás közben újra fordítani?
Nem tudom, de azt csinálja és láthatóan jó eredménnyel. Egyébként abban is sok igazság van, amit te írtál. Hiába dolgoz fel egy százmilliós tömböt gyorsabban a Java-ban írt program, mint a C-ben írt, a felhasználók jelentős részének - teljesen természetes módon - az marad majd meg a Java programból, hogy lassan indul el, nem reszponzív a gui, idegenek a swing komponensek, stb.
> Honnan tudja futás közben, hogy hogyan lehet optimalizáltabb?
Erre van utalás a linkelt cikkben, igaz, nem a Java, hanem a CPU-k kapcsán. El tudom képzelni, hogy a VM a byte kód elemzésekor csinál valamilyen branch prediction-t vagy mondjuk előre lefordít mindkét lehetőségre egy natív kódrészeletet, amivel kiküszöböli a lokális ugrásokat.
-
alapz@j
tag
Szerintem ebben lehet a titok. Az első párezer (párszázezer) ciklus után talán a compiler újrafordítja. Olyan tool kellene, amivel futás közben lehet megfigyelni a kód változását.
-
alapz@j
tag
A java vs. c témakörhöz egy kis nem-annyira-offtopic szösszenet:
http://tifyty.wordpress.com/2012/07/15/es-a-jit-optimalizal-de-meg-mennyire/
-
alapz@j
tag
A C az gyakorlatilag platformfuggetlen assembler, ami tamogat strukturalt programozast is, manapsag mar leginkabb csak par specialis helyen hasznaljak.
A C++ ennek eggyel jobban elvont valtozata, ami tamogatja a nyolcvanas meg kilencvenes evek, sot, a 2011-es C++11 szabvany (amit olyan nagyon sok helyen meg nem hasznalnak) egyre inkabb a XXI. sz. elejenek mindenfele dolgait (objektumorientalt programozas, template-ek, ill. parhuzamos programozas, stb), de meg mindig nativ kodot futtat. Nekem ugy tunik, hogy manapsag ez a fo nyelv, ha nagy projekteket csinalnak.
A C# meg tulajdonkeppen a Java Microsoft-fele valtozata, meg egy fokkal elvontabb, virtualis gepek programozasara szantak es persze a Microsoft-vilagon kivul nem nagyon mukodik.
> A C az gyakorlatilag platformfuggetlen assembler...
Haha, ez nagyon tetszik!
-
alapz@j
tag
Nem szabvány szerinti függvény.Nálunk a C99 használatos.(#4413) alapz@j: A .NET alatt szinte mindeki a C#-ra gondol függetlenül attól, hogy nem csak abban lehet programozni.
(#4414) alapz@j: A C++ ahogy mondtad platform független, az hogy te mennyi függőséget viszel bele az már a te dolgod. Nem mellesleg a platform függetlenség alatt nem csak az OS-ek közötti átjárásra gondoltam hanem architektúra és rendszer váltásra is.
A Java pedig sajnos erőforrás igényes. Nézz meg egy Vuze-t (amióta átírták Java-ra azóta megy a panaszkodás, hogy nagy megterheli a gépet) vagy ott a Minecraft. Amilyen egyszerű a grafikája olyannyira erőforrás zabáló. A LibreOffice-ban sem véletlenül írják át folyamatosan a Java kódot C++-ra.
A Minecraft teljesen alap Java-OpenGL bridge-t használ, azaz a megjelenítést a hardver végzi, ha simán portolnák C/C++-ra, nem gyorsulna érdemben - az értékelhető gyorsuláshoz az egész engine-t újra kellene írni. Hozzáteszem, igen régi gép kell már ahhoz, hogy a Minecraft gondban legyen, utoljára talán a csajom core2duo+intel hd kombós gépén láttam szaggatni...
-
alapz@j
tag
Amit írtál az mind OOP nyelv. Ha android, akkor Java. Ha windows phone, akkor .net, ha iPhone akkor objective C. A Java mellett szól, hogy mindenen fut, amin van Java virtuális gép, de lassú és sok memóriát igényel, és az Oracle-höz vagy kötve. A C++-ban teljes szabadság uralkodik, mert sem céghez, sem oprendszerhez, sem platformhoz nem vagy kötve, és annyira nem vészes. A .net alatt teljes zártság és kötöttség van. Viszont ha windowson kívül másra nem akarsz fejleszteni, akkor talán még ez a legjobb választás.
Ööö, ööö. A Java nem feltétlenül lassú és nem is foglal feltétlenül sok memóriát. 2000-ben ez így volt, ma már nincs - és az Oracle-höz sem vagy kötve mert van még egy tucatnyi másik implementáció. Az oracle-ös HotSpot csak a reference. A C++ platformfüggetlensége pedig megint csak kérdőjeles, mert a cout << "Hello World" tuti működik minden rendszeren, de ha elkezded benne meghívni az OS API függvényeit (mert egy natív GUI-t építesz), akkor máris ugrott a függetlenség.
-
alapz@j
tag
értem, ez kis könnyedséget adott most, remélem a java akkor jobban fog tetszeni.

Egyébként ti milyen nyelveket ajánlanátok? Mit érdemes tanulni? Tudom, hogy ez megint csak 1 nagyon szubjektív dolog, de pl. mi a véleményetek a c++ (bár úgy tudom ez nagyon expert programozóknak ajánlott csak), vagy a .net-ről?
Azt tudom, hogy a java-t azért mondják relatív könnyűnek, mert OOP nyelv, de pl a .Net-ről nemtok semmit, meg a c++-ról is csak annyit, mint amit előbb leírtam (ergó semmit)A .NET nem programnyelv, hanem egy framework, amit tucatnyi nyelven lehet programozni.
-
alapz@j
tag
Fel kell venni azt a bizonyos szemüveget, amivel a fontos és jelentéktelen warningokat ki lehet válogatni. Szerintem a strcat_s egy beépített függvény a VS-nek, így inkább javaslat lesz, mint valós warning. A standradban egészen biztosan nincs ilyen. Nem kell azzal foglalkozni. Függően attól, hogy merre szeretnél tovább tanulni én javasolnám a mingw (GCC) + eclipse kombót. A VS nagyon lekorlátoz. Gyakorlatilag csak PC-re és csak Windowsra tudsz fejleszteni. GCC + Eclipse-szel gyakorlatilag minden platformra tudsz fejleszteni.
IDE - Integrated Development Environment, a debuggerrel pedig lépkedni tudsz a kódban futás közben. Meg tudod nézni, hogy az adott változónak mi az értéke. Meg is lehet változtatni. Break pointokkal meg lehet állítani a program futását. Nagyon hasznos ha algoritmusbeli hibát szeretnél kidebbugolni.
Már hogy ne lenne standard a sec_api? Minden függvénynem megvan a _s (secure) verziója, amelyik figyel a túlcsordulásokra, a VS pedig alapból warning-ot ad, ha nem azokat használja valaki.
-
alapz@j
tag
Én azt vettem észre hogy akik programozást kezdenek tanulni azok közül sokan nem tudják hogy mi is az a program, hogyan készül, mi van az egész programozás mögött. Annyit látnak hogy begépelik a programsorokat, jó esetben tudják a programnyelv elemeit használni és azt tudatosan teszik, de sajnos azzal hogy a forráskód megírása után mi is történik, miért szükséges fordítani (vagy egy virtuális gépnek átadni, esetleg egy interpreterrel feldolgoztatni) arról nincs fogalmuk.
Egy képletes példa: A király elhatározza hogy palotát épít, olyat amilyet még nem látott a világ. Az utazók kíváncsian fogják felkeresni a várost, hogy csodájára járjanak majd ennek a nem mindennapi építmények. A kőfejtőben, ahol a palotához hasítják a kőtömböket, megkérdeznek két munkást hogy mit gondolnak, mit csinálnak itt egész nap.
Az első azt mondja: Egész nap izzadok, fejtem a követ itt a koszos, poros bányában. Nem tudom meddig bírom, már nagyon unom az egészet, lehet hogy más munka után nézek.
A második ezt mondja: Én palotát építek!A tanmesének vége. A lényeg hogy ha tudja az ember hogy mit csinál, sokkal nagyobb kedvvel, elhivatottsággal, lelkesedéssel, izgalommal telve végzi a munkáját.
Így van ez a programozással is. Kell hogy a programozó tisztában legyen a háttérben zajló dolgokkal, mert sokkal izgalmasabb lesz az egész programozás ettől! Akkor is ha interpretert használ, akkor is ha köztes bájtkódot és akkor is ha gépikódra fordított programot készít.A konklúzióval egyetértek, de a folyamattal nem. Egy programozást, mint hobbit megtanulni vágyó embernek soha nem kezdeném azzal az oktatását, hogy na, van a compiler, ami az "elso_valtozom = 0" programsorodat valami olyasmivé alakítja majd át, hogy "mov [elso_valtozom], 0", csak éppen binárisban, de előtt még írjál köré olyanokat, hogy "int main()" és "return 0".
-
alapz@j
tag
Ahogy a többiek írták, rosszul gondolkodsz a dologról. Olyan mintha szeretnél egy sportautóval megtanulni száguldani, de előtte a biztonság kedvéért veszel egy markológépet amivel tök sok mindent meg lehet csinálni, és azon kezdesz tanulni vezetni, hiszen annak is négy kereke van.
Ha modern dolgokat akarsz akkor valamilyen objektum orientált nyelvet válassz, amihez van valamilyen jó framework. Ilyen nyelvek/környezetek a Java, C#, és a C++ is, de előtte keményen oop elméletet kell elsajátítani.
Ha rendszerprogramozás a cél akkor tökéletes a C.Ha egyszerüen csak meg akarod tanulni a programozás alapjait, vezérlési szerkezeteit, akkor jó lehet a Pascal.
Programozást nulláról tanulni szerintem az interpretált nyelvek a legjobbak, mert nem kell a fordítás nyűgjével és az esetleges hibák komolyabb következményivel foglalkozni: Python, Perl, Ruby, Lua, bár ez utóbbi kettő nem feltétlenül jó kezdőnyelv. Esetleg JavaScript és akkor egyből GUI is van

Ha az alapok megvannak, akkor lehet abban gondolkodni, hogy a kitűzött célhoz melyik nyelv illene e legjobban.
-
alapz@j
tag
Szia!
Szerintem azért, mert sokan elfelejtik, hogy a realloc-nak a visszatérési értékét kell odaadni a pointernek. Ezt sokan elfelejtik, ugyanis ha új helyre másolja, akkor értelemszerűen a pointernek is változnia kell. Személy szerint nem tudom, hogy mi más probléma lenne ebből. Igaz, nálunk tiltott mindennemű dinamikus memória foglalás, mert ha használnánk, akkor a rendszer előbb utóbb lefagyna.
Megkérdezhetem, hogy milyen rendszert használtok, ami lefagy a dinamikus memória-foglalástól? MS DOS 3.0?

-
alapz@j
tag
Én mindig ugyanabba a sorba rakom a nyitó kapcsost, még függvény definíciónál is
int main(void) {
return 0;
}a típusjelölésre teszem a csillagot, mert olvashatóbb
char* nothing(char* string) {
return string;
}Ja, és egy sorra soha nem használok kapcsost:
if (..)
for (...)
printf("Hit me!\n");
Hm, most látom csak hogy beírtam a voidot a paraméterek helyére - nem tudom, hogy ez mennyire szabványos, de a Pelles C compiler állandóan aggódik, ha nem teszem, ezért hozzászoktam

-
alapz@j
tag
Már hogyne volna C stílusú ez a fajta zárójelezés.
Amellett, hogy Ritchie eléggé a nyelv alkotója, nagy open source projektekben is előfordul, hogy ez a forma mellett döntenek.De persze az is gyakori, hogy új sorba rakják. C-ben én is úgy szoktam, de ettől nem lesz univerzális igazság.
Én mindig ugyanabba a sorba rakom a nyitó kapcsost, még függvény definíciónál is
int main(void) {
return 0;
}a típusjelölésre teszem a csillagot, mert olvashatóbb
char* nothing(char* string) {
return string;
}Ja, és egy sorra soha nem használok kapcsost:
if (..)
for (...)
printf("Hit me!\n");
-
alapz@j
tag
Az akkor lehet, ha elfelejtetted hozzálinkelni a math könyvtárat. Minden bizonnyal valamit panaszkodott is a fordító, legközelebb azt is írd meg nekünk, valamint keress rá az interneten is. Jelen esetben valószínűleg undefined reference hibát kaptál ami azt jelenti, a linker nem talált valami hivatkozott szimbólumot. Ilyenkor ha nem elírás történt, akkor hiányzó könyvtárak/modulok felé kell keresgélni. Konstansra azért fordulhat, mert azt szerencsés esetben a fordító kiszámolja így nincs szükség a tényleges atan implementációra.
Végül pedig a gyógymódról. Nem írtad milyen környezetet használsz, parancssoros gcc esetén -lm kapcsolót kell alkalmazni. A -l segítségével lehet függvénykönyvtárakat hozzáadni a beszédes m pedig a matek könyvtár neve. IDE környezetben meg kell keresni hol lehet további könyvtárakat (library) beállítani és ott fel kell venni a matek könyvtárat.
A math.h mintha már benne lenne a C90 és C99 szabványokban ezért nem kell explicit módon linkelni a könyvtárat. Most próbáltam egy x86_64-w64-mingw32 / gcc 4.8.1 csomaggal és "-Wall -pedantic" kapcsolókkal is lefordul hiba vagy warning nélkül...
-
alapz@j
tag
Ahogy a kollega írta, logikailag megsemmisül és a szabvány csak ennyit ír elő.
Az már fordítófüggő, hogy ez hogyan néz ki gépi kód szinten, de rendesen optimalizáló fordító nyilván előre lefoglalja a területet és újrahasznosítja. Mellesleg a stack kezelésnek igen minimális az overheadje hiszen csak egy-egy pointer művelet.Ha érdekel a végeredmény hogy néz ki akkor kérj assembly listát a fordítódtól vagy használd ezt a remek weboldalt.
Huh, nagyon jó ez a GCC Explorer, meg is adta a választ:
int main() {
for (int i = 0; i < 5; ++i) {
int x = i + 10;
}
}g++ 4.8 (-O és más kapcsolók nélkül)
main:
push rbp
mov rbp, rsp
mov DWORD PTR [rbp-8], 0
jmp .L2
.L3:
mov eax, DWORD PTR [rbp-8]
add eax, 10
mov DWORD PTR [rbp-4], eax
add DWORD PTR [rbp-8], 1
.L2:
cmp DWORD PTR [rbp-8], 4
jle .L3
mov eax, 0
pop rbp
retÉrdekes, ha jól olvasom, akkor a teljes stack allokálás (int i és int x is) megtörténik már a ciklus előtt, azaz nincs sem menet közbeni allokálás, sem blokk utáni deallokálás.
-
alapz@j
tag
Igazából nem az érték megmaradása, hanem az esetleges stack-kezelés overhead (illetve annak elkerülése) miatt érdekelne.
-
alapz@j
tag
Egy C99
for (..) {
int x = ...
}ciklusban az x minden iterációnál létrejön/megsemmisül a stack-en vagy csak egyszer és mindig az kerül felhasználásra?
-
alapz@j
tag
Esetleg bővebben is ki tudnád fejteni a jelenséget? Milyen program, milyen hibaüzenetet ad, stb?
Új hozzászólás Aktív témák
-
Fórumok
Mobilarena - mobil fórumok
Okostelefonok Mobiltelefonok Okosórák Autó+mobil Üzlet és Szolgáltatások Mobilalkalmazások Tartozékok, egyebek Mobilarena blogokPROHARDVER! - hardver fórumok
Notebookok TV & Audió Digitális fényképezés Alaplapok, chipsetek, memóriák Processzorok, tuning Hűtés, házak, tápok, modding Videokártyák Monitorok Adattárolás Multimédia, életmód, 3D nyomtatás Tabletek, E-bookok Nyomtatók, szkennerek PC, mini PC, barebone, szerver Beviteli eszközök Egyéb hardverek PROHARDVER! BlogokIT café - infotech fórumok
Infotech Hálózat, szolgáltatók OS, alkalmazások SzoftverfejlesztésGAMEPOD - játék fórumok
PC játékok Konzol játékok MobiljátékokLOGOUT - lépj ki, lépj be!
LOGOUT reakciók Monologoszféra FototrendFÁRADT GŐZ - közösségi tér szinte bármiről
Tudomány, oktatás Sport, életmód, utazás, egészség Kultúra, művészet, média Gazdaság, jog Technika, hobbi, otthon Társadalom, közélet Egyéb Lokál PROHARDVER! interaktív
● olvasd el a téma összefoglalót!
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- BMW topik
- MasterDeeJay: Low budget (50.000 forint) light gémer gép összerakása
- Horgász topik
- Feltalálta a Google a keresőmotort
- Jelszókezelők
- Okos lesz a következő szemüveged
- Samsung Galaxy A56 - megbízható középszerűség
- AMD Navi Radeon™ RX 9xxx sorozat
- Fejhallgató erősítő és DAC topik
- gban: Ingyen kellene, de tegnapra
- További aktív témák...
- Dell Latitude 3380 - Core i3 6006U, 4-8GB DDR4 RAM, gyári töltő, számla, 6 hó gar
- 27% - ÚJ Kingston FURY Beast 64GB (2x32GB) DDR5 5600MHz KF556C36BBEK2-64
- Apple iPhone 15 Pro 128GB eladó! 86% akku, Patika állapot, 12 hónap garancia
- Apple iPhone 16 Pro Max 256GB eladó! 94% Akku, Szép állapot, 12 hó gar
- Apple iPhone 15 Pro Max 256GB eladó! 89% Akku, Patika, 12 hó garancia
- Gaming PC! Ryzen 5700X / RTX 3070 / B550 / 32GB 2666Mhz / 512GB NVMe / 850w Gold! BeszámítOK
- iPad felvásárlás!! Apple iPad, iPad Mini, iPad Air, iPad Pro
- Samsung Galaxy Tab S9 Ultra 5G 256GB 12GB RAM Graphite Karcmentes állapotban 2027.05.15-ig garancia
- AKCIÓ! 1TB NVMe SSD, 1 év gar 2230
- Törött, Hibás iPhone felvásárlás!!
Állásajánlatok
Cég: Laptopműhely Bt.
Város: Budapest

![;]](http://cdn.rios.hu/dl/s/v1.gif)


Mennyivel nyugisabb lenne az utolsó munkanap.
locks-ot találtam. egyéb ötlet?



. Én személy szerint nem tanultam mást csak C-t. Ön szorgalomból tanultam meg a PERL-t, C++-t, egy kicsit a bash-t.
Amellett, hogy Ritchie eléggé a nyelv alkotója, nagy open source projektekben is előfordul, hogy ez a forma mellett döntenek.


