- gban: Ingyen kellene, de tegnapra
- Kempingezés és sátrazás
- Gurulunk, WAZE?!
- Magga: PLEX: multimédia az egész lakásban
- f(x)=exp(x): A laposföld elmebaj: Vissza a jövőbe!
- Parci: Milyen mosógépet vegyek?
- Luck Dragon: Asszociációs játék. :)
- sziku69: Fűzzük össze a szavakat :)
- sziku69: Szólánc.
- ubyegon2: Airfryer XL XXL forrólevegős sütő gyakorlati tanácsok, ötletek, receptek
Új hozzászólás Aktív témák
-
axioma
veterán
válasz
bucsupeti
#4299
üzenetére
Ez azert olyan 20 evvel ezelott keringi "Az igazi programozo" c. irasra emlekezteto fordulat volt... szerintem ez egy kicsit generacios kerdes is. A gyerekemnek mar az lesz trivialitas, hogy leir (ha egyaltalan szo szerint iras lesz az me'g) egy kodsort es mar a masik ablakban fut is a modositott program. Az en szuleim korosztalyaban (o"k konkretan nem) levo, korai programozok viszont felvezeto szinten, nand kapukra felbontott logikai kifejezesek nelkul nem tudta elkepzelni, hogy valaki programozni fog tudni. [En valahol a ketto kozott vagyok.] Es ez me'g csak nem is azert van, hogy mi volt az elterjedtseg akkor, es mi most. Vagy hogy milyen a fejlesztokornyezet, es milyen most. Egyszeruen bovult az egesz "programozas" fogalom, es egyben specializalodott is. Egy magasszintu program megirasahoz szerintem nem alapveto tudas a forditas miertjenek melyrehatobb (meddig melyre?) ismerete, csak a szuksegessege es a modja (mondjuk ha ide vesszuk az internetet meg az rtfm-et is, akkor inkabb csak a szuksegesseg ismerete). Viszont mindig lesz olyan, aki meg hw-kozeli dolgokat csinal, es adott esetben aka'r lenezi a magas szinten programozokat, akik egy chip labait se tudjak megkulonboztetni egymastol, vagy nem tudja megmondani, hogy adott asm kod hany usec nagysagrendig fut.
Szerintem minden nagyon mulik a feladatokon, amiket meg kell oldani, nem lehet azt mondani hogy ez vagy az nelkul nem lehet programozni. Legfeljebb a programozas bizonyos alfaja't nem konnyu nelkule muvelni. -
bucsupeti
senior tag
válasz
alapz@j
#4298
üzenetére
igazad van. én sem kezdeném így. Azt viszont elmondanám hogy van a processzor, meg a memória stb. Aztán van egy olyan hogy oprendszer, ami müködteti az egészet. a programok hogyan hová töltődnek és hogy indulnak el stb... Ez nélkül nehéz elképzelni hogy valaki jó programozó lesz...
-
alapz@j
tag
válasz
bucsupeti
#4297
üzenetére
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".
-
bucsupeti
senior tag
válasz
alapz@j
#4296
üzenetére
É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. -
alapz@j
tag
válasz
bucsupeti
#4295
üzenetére
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.
-
#4295
bucsupeti
senior tag
superfinest
#4290
bucsupeti
senior tag
válasz
superfinest
#4290
üzenetére
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.
-
#4294
kingabo
őstag
superfinest
#4288
kingabo
őstag
válasz
superfinest
#4288
üzenetére
A C-hez és a Javahoz gyakorlatilag teljesen másmilyen gondolkodás mód szükséges, hiába vannak közös nyelvi elemek. Ahogy már mások is írták, emiatt nem lesz sok előnyöd a C megtanulása után ahhoz képest, aki egyből a Javaval kezd, viszont sok időd elmehet vele és valószínű vért fogsz izzadni. Ráadásul sok a kezdők szemében "hibára" vagy nehézségre a java már vagy tartalmaz valamilyen nyelvi elemet, vagy megoldást, amikkel az általad kitűzött célokat könnyebben és gyorsabban el tudod érni.
-
#4293
fordfairlane
veterán
superfinest
#4290
fordfairlane
veterán
válasz
superfinest
#4290
üzenetére
Azért gondoltam először a C nyelvet tanulom, mert ez sok nyelv alapja "elvileg", javíts ha rosszul tudom.
Inkább csak hasonló szintaktikájúak bizonyos vezérlési szerkezeteket illetően. Jobban jársz magasabb szintű programnyelvvel, szerintem, hacsak nem hardverközeli programozást szeretnél megtanulni, mert akkor a gépközelibb C a jobb választás.
-
#4292
Ereshkigal
őstag
superfinest
#4290
Ereshkigal
őstag
válasz
superfinest
#4290
üzenetére
Ha belátható időn belül "csak" kedvtelésből akarsz programozgatni, akkor én személy szerint a Java-t vagy a C#-ot javaslom neked. Csomó mindent "elébed tesznek", csak használni kell. Könnyebben, gyorsabban fogsz leprogramozni olyan dolgokat, amikkel C-ben rengeteg időd elmenne...
Nem elfogultságból ajánlom ezt, mert az én szívem a C és a C++ felé húz, na de én sejtautomatákat programozok + sokat számolok.
-
#4291
axioma
veterán
superfinest
#4290
axioma
veterán
válasz
superfinest
#4290
üzenetére
Hiaba alap, a rae'pules pont azert van, mert pluszt nyujtanak a tovabbi nyelvek. Csak egy tokegyszeru pelda: dinamikus (futas kozben valtozo hosszu) tomb, lista, vagy barmi megvalositasa. Ha ansi C-ben megirod nullarol, megtanulsz egy csomo alacsonyabb szintu kezelest es kezdokent ve'rt izzadsz hogy jol kovesd le, jol foglalj helyet es szabadits fel stb. mig java-ban meg letrehozol egy (mondjuk) ArrayList-et, azt annyi. Nem beszelve arrol, hogy ha C-ben levo kodot kell egy nem kimondottan szepen kodolo embertol visszafejtene'd, az megint egy nyomozassal feler (persze java-ban is lehet ilyet elkovetni, foleg ha 2-3 betus valtozoneveket es/vagy mas nyelvu roviditeseket hasznal - multkor neztem egy ruszki programozo versenymegoldasat ahol ugye nincs ido csicsazni, eleg erdekes volt visszafejteni a core algot, de C-ben pont a nagyon nagy rugalmassag miatt nagyon nagy randasagot is el lehet kovetni ugy, hogy helyes, csak attekinthetetlen).
-
superfinest
tag
válasz
buherton
#4289
üzenetére
Igazából nekem 1-2 dologhoz kellene a programozás. pl.: San Andreas Multiplayer scripteléshez és/vagy Java alapú dolgok programozásához, úgyhogy tényleg hasznosabb lenne a Java, Pawno. Nemtudom, hogy ezt a 2 nyelvet lehet-e párhuzamosan tanulni.
Azért gondoltam először a C nyelvet tanulom, mert ez sok nyelv alapja "elvileg", javíts ha rosszul tudom. -
#4289
buherton
őstag
superfinest
#4288
buherton
őstag
válasz
superfinest
#4288
üzenetére
Miért nem kezdesz akkor Java-val? Nem sok hasonlóság van a C és a Java nyelv között se. Ha megtanulod a C-t, akkor a Java-nál újra kell tanulnod még egyszer annyit, de inkább többet, mert teljesen más a paradigma. Bocsi de szerintem teljesen logikátlan, amit csinálsz. Ráadásul olyannal nyelvvel kezded, amire 99% az esély nem kell majd neked.
Én C-t tanultam, mert abban szerettem volna programozni, és abban is kell programoznom a munkahelyen.
-
#4288
superfinest
tag
superfinest
tag
Üdv!
Elég sok szabad időm van. C-ben szeretnék megtanulni programozni, mivel úgy gondolom, hogy ez jó alapot ad az egyszerűbb nyelvekhez. pl. Java, Lua, Python-hoz
Programozni csupán hobby-ból szeretnék, mivel eléggé megtetszett ez az egész dolog. Olvastam pár elméleti dolgot a C-vel kapcsolatban, csupán a gyakorlatba vannak gondok amikor el kell kezdeni tényleges programozni. Jelenleg ezeket tanulmányozom:Magyarázatot elolvasom és logika/megjegyzés alapján próbálom gyakorlatba csinálni a leírtakat.
Plusz egy-két könyvet is fogok kölcsönözni az alapok megtanulásához.
Csak el kellene kezdenem, valahol.
De minden kezdet nehéz ugyebár. -
#4287
kispx
addikt
superfinest
#4284
kispx
addikt
válasz
superfinest
#4284
üzenetére
Nem egy a kettő, sok különbség van.
-
#4286
buherton
őstag
superfinest
#4284
buherton
őstag
válasz
superfinest
#4284
üzenetére
Ebben nagyon is tévedsz. Az egy dolog, hogy a C++ visszafelé kompatibilis a C-vel, de ezzel nagyjából be is fejeződött a kapcsolat/hasonlóság. Döntsd el, hogy C-ben vagy C++-ban szeretnél-e megtanulni programozni, és a jövőben ne keverd a kettőt. Ha komolyan akarsz programozni, akkor a C++-t érdemes megtanulni.
-
#4285
Korcsii
őstag
superfinest
#4284
Korcsii
őstag
válasz
superfinest
#4284
üzenetére
Két külön nyelv a kettő. Más kérdés, hogy a megfelelő headerek behívásával lehet használni a C-s függvényeket is C++ alatt. Éppen emiatt a fejlesztőkörnyezetek is általában támogatják mindkettőt.
Az általad írt példakód egyértelműen C.
Milyen megfontolásból szeretnél elkezdeni C nyelven tanulni?
-
#4283
kingabo
őstag
superfinest
#4282
kingabo
őstag
válasz
superfinest
#4282
üzenetére
Hali!
Ez a C és nem a C++ topik. Másrészt felül a téma összefoglalóban könyveket, oldalakat is ajánlanak.
-
#4282
superfinest
tag
superfinest
tag
Üdv!
A C++ nyelvvel szeretnék foglalkozni, azonban nem tudom honnan kellene elkezdeni ezt az egész dolgot. Nagyon alap programokat össze tudok dobni, de ennél többre nem futja. pl.:#include <stdio.h>
void main(){
int a, b, c;
printf("Kerek egy szamot: ");
scanf("%d", &a);
printf("Kerek meg egy szamot: ");
scanf("%d", &b);
c = a + b;
printf("A számok osszege: ");
printf("%d", c);
}Esetleg tudtok-e olyan magyar nyelvű oldalakat, ahonnan lehetne bővíteni/fejleszteni a tudásom.
A válaszokat előre is köszönöm!
-
Peter789
senior tag
válasz
skylaner
#4280
üzenetére
Köszi, ez volt amit kerestem...
Közben felmerült egy másik kérdés is: van elegánsabb/gyorsabb megoldás több fájl egyidejű törlésére, mint a system("rm valami*") ? Vagy ki kell listázni, szűrni és egyesével törölni? A platformfüggőség nem katasztrófa, lévén hogy ez a program kizárólag openwrt-n fog futni és a fejlesztés is ubuntun zajlik, viszont az erőforrásigényt jó lenne minimalizálni amennyire lehet...
-
Peter789
senior tag
Sziasztok!
Hogyan lehet egy float változót egy string-be átrakni megformázva? Valami hasonlót keresek, mint amit itt csinál a printf, de egy karakterlánc string-be kellene kerülnie az eredménynek amit utána fel tudok használni pl egy fájlnév megadásánál az open függvényben...
float ftmp = 19.52466;
printf("%.1f",ftmp);kimenet: 19.5
Előre is köszönöm a választ!
-
Jester01
veterán
Csinálsz egy ciklust ami végigmegy a tömbön (ez lesz a forrás pozíció) és egy változót ami a cél pozíciót tárolja. Ha az adott elemet meg kell tartani, akkor a forrásból a célba másolod és növeled a cél pozíciót, különben nem.
dst = 0;
for(src = 0; src < len; src++) {
if (!pred(a[src])) a[dst++] = a[src];
} -
axioma
veterán
Ha jol ertem, akkor a fejedben nem az a tabulalas van meg, amit a programnak adtal. Vagyis a 45. sorban levo "else" kene legyen a tenyleges feldolgozo a'g, csak nem raktad ki a zarojeleket, es az egyedul az ott kezdodo if-re vonatkozik. Ami veget er a 48.-ban, tehat a 49.-ben levo me'g ures sor eseten is vegrehajtando.
Rakd ki az else utan a blokk-kezdest, ami vegzodik a while vege elott, a 60. sornal.
Valoszinuleg az "osszenott" else if okozta, hogy nem latod pontosan a strukturat. Ilyen egybeirt else if -et en csak akkor szoktam csinalni, ha tobb darab, 1 sorba befero rovid vizsgalat es 1 soros rovid blokk tartozik hozza, szinte egy switch tipusu egymas melletti esetfelsorolas lenne, csak mas tipusu a feltetelem. Mondjuk ilyenkor annak megfeleloen is tabulalom, tehat minden else if blokkja az egybeirastol fuggetlenul uj szintre kerul be. Minden mas esetben hasznos, ha minden nagyobb else-hez kirakod a sajat kezdo-zaro parjat. Szigorubb coding standard szerintem alapbol meg is koveteli. -
0xmilan
addikt
válasz
skylaner
#4269
üzenetére
Köszi, jogos.
Megnéztem egy régebbi példát, és annak mintájára külön függvénnyel fűztem a lista elejére.
Most így néz ki a működő verzió:
...
while(!feof(fp)){
fgets(temp, 256, fp);
sscanf(temp, "%d %[^\t] %[^\t] %[^\t] %[^\t] %[^\t] %c", &szint, &tempk, &tempa, &tempb, &tempc, &tempd, &valasz);
lista=elejere(lista, szint, tempk, tempa, tempb, tempc, tempd, valasz);
}
}
...
Kerdes* elejere(Kerdes *lista, int szint, char* tempk, char* tempa, char* tempb, char* tempc, char* tempd, char valasz){
Kerdes *uj;
uj=(Kerdes*) malloc(sizeof(Kerdes));
uj->szint=szint;
uj->ker=(char*) malloc((strlen(tempk)+1)*sizeof(char));
strcpy(uj->ker,tempk);
uj->a=(char*) malloc((strlen(tempa)+1)*sizeof(char));
strcpy(uj->a,tempa);
uj->b=(char*) malloc((strlen(tempb)+1)*sizeof(char));
strcpy(uj->b,tempb);
uj->c=(char*) malloc((strlen(tempc)+1)*sizeof(char));
strcpy(uj->c,tempc);
uj->d=(char*) malloc((strlen(tempd)+1)*sizeof(char));
strcpy(uj->d,tempd);
uj->valasz=valasz;
uj->kov=lista;
return uj;
}Most fgets-szel beolvasok egy sort, aztán sscanf-fel meg tabulátoronként darabolom és aztán rakom új listaelembe.
A listának meg nem is kellett volna helyet foglalni, mert az csak egy pointer..
Még egyszer kösz a segítséget mindenkinek! -
buherton
őstag
-
randi
újonc
Üdv mindenkinek!
Ebben az évben kezdtem foglalkozni C programozással, és a legutolsó házimmal nem boldogulok. A feladat a következő:
"Írjon cenzúrázó programot. A program beolvas egy mondatot, majd egy tiltott karaktersorozatot. A mondatban kicseréli a karaktersorozat minden előfordulását 3 csillag karakterre (a cenzúrázott szó helyett három csillagot rajzol). Végül kiírja a cenzúrázott mondatot.A feladat megoldása közben csak a gets, scanf és a prinf függvények használhatók. NEM szabad előre megírt stringkezelő függvényeket használni.
Például:
Miben cenzurazzak?
Az ipafai papnak fapipaja van, tehat az ipafai papi pipa papi fapipa.
Tiltott szo? pa
A cenzurazott mondat:
Az i***fai ***pnak fapi***ja van, tehat az i***fai ***pi pi*** ***pi fapi***.
Press Enter to return to Quincy..."
Odáig eljutottam, hogyha megtalálja a tiltott szót, akkor a karaktereket csillagra cseréli. Sőt a mondatot is arrébb tudtam másolni. Csak az a baj, hogy annyi csillagot ír, ahány karakterből áll a tiltott szó, és nem - a feladatban megadott - hármat.
Ha valaki tudna segíteni, annak nagyon megköszönném. Ja, és nem vagyok már mai csirke -
0xmilan
addikt
válasz
skoda12
#4264
üzenetére
Ezer köszi segítséget!
A túlindexelést egy levlistán olvastam, aztán bele se gondoltam, hogy hülyeség.
..Pont az a baj, hogy nem ismert a stringek hossza, és - bár megadhatnék egy max. hosszt - , a lényeg, hogy egy bájttal se használjak több memóriát, mint amennyi tényleg kell.Kösz a tippet a dubeggerre. Korábban már használtam, de elszoktam tőle, aztán megmutatta, hogy működik a beolvasás, csak nem úgy, ahogy én azt gondoltam.
tempk-ba egy kérdést várnék (legyenönismilliomost írok), amiben ugye több szóköz van, én meg azt hittem, hogy majd kitalálja meddig tart a kérdés.
Így utólag elég hülyének érzem magam.
Szóval elkezdte szépen bepakolni a kérdés egyes szavait a válaszok sztringjeibe.
Ezek szerint itt az fscanf nem is használható..? Mindenképpen karakterenként kéne beolvasni?Olyat tudok, hogy karaktert vizsgálni, azon belül meg stringet olvasni?
pl így:while (fgetc(fp) != '9'){ - elvileg a TAB kódja
fscanf(fp, "%s", &tempk);
...+ mindig hozzáfűzögetni az új szavakat;
} -
skoda12
aktív tag
válasz
0xmilan
#4263
üzenetére
uj->ker[strlen(tempk)+1]='\0';
Ezeken a helyeken tulindexeled a tombot. Ha a tomb strlen(tempk) + 1 elembol all, akkor az utolso elemre az strlen(tempk) indexszel tudsz hivatkozni. Amugy a fenti explicit \0 iras nem szukseges, mert az strcpy a lezaro \0-t is atmasolja. Tovabba, ha mar ismert elore a stringek maximalis hossza, mint a temp valtozoid eseten, akkor erdemes lenne fix hosszal tarolni oket a struct-ban es egybol ezekbe olvasni. Igy megkimelned magad egy csomo pointerezestol es masolgatastol.
+ erdemes lenne megismerkedned valami debuggerrel, amivel sorrol sorra lepkedve tudnad futtatni a programodat, hogy az ilyen programmeghalos hibakat konnyebben megtalald. Kezdetben boven eleg lesz egy alap gdb tutorial a break, c, n, s parancsokkal -
0xmilan
addikt
válasz
skoda12
#4262
üzenetére
Tényleg, köszi! Nem is a listaba, hanem az uj-ba kellett volna beolvasnom, meg strcpy-zni aztán onnan meg a lista=uj és akkor elvileg az elejére fűződik.
átírtam az adott részt így:
uj->ker=(char*) malloc((strlen(tempk)+1)*sizeof(char));
lista->ker=(char*) malloc((strlen(tempk)+1)*sizeof(char));
strcpy(uj->ker,tempk);
uj->ker[strlen(tempk)+1]='\0';
uj->a=(char*) malloc((strlen(tempa)+1)*sizeof(char));
lista->a=(char*) malloc((strlen(tempk)+1)*sizeof(char));
strcpy(uj->a,tempa);
stb
.
.és akkor a végére mindig be kéne szúrni a \0-t így?:
uj->ker[strlen(tempk)+1]='\0';Ha jól tudom azért kell NULL-lal hívni, mert akkor az lesz a vége és így tudom bejárni, hogy a nullpointer a kilépési feltétel.
(ja amúgy ugyanúgy lefagy)
-
skoda12
aktív tag
válasz
0xmilan
#4261
üzenetére
Ket hibat latok elsore. Az egyik, hogy az "uj" char* elemeinek foglalsz helyet mallockal, de a "lista" inicializalatlan elemeibe probalsz masolni strcpyvel. A masik, hogy az ilyen inicializalasoknal
uj->ker=(char*) malloc(strlen(tempk)*sizeof(char));nem veszed figyelembe, hogy majd a lezaro \0-nak is kellene egy hely a karakterlanc vegen.
+ nincs ertelme NULL-lal meghivni a beolvas fuggvenyt, bar ebben az esetben nem emiatt mukodik rosszul a kod.
-
0xmilan
addikt
Üdv, láncolt listába szeretnék beolvasni fájlból.
Így néz ki a struktúra:
typedef struct Kerdes{
int szint;
char *ker, *a, *b, *c, *d;
char valasz;
struct Kerdes *kov;
} Kerdes;és a függvény:
Kerdes* beolvas(Kerdes *lista){
FILE *fp;
Kerdes *uj;
char c;
uj=(Kerdes*) malloc(sizeof(Kerdes));
lista=(Kerdes*) malloc(sizeof(Kerdes));
char tempk[256], tempa[50], tempb[50], tempc[50], tempd[50];
fp = fopen("loim.txt", "rt");
if (fp == NULL) printf("Nem sikerült megnyitni!");
else{
while(!feof(fp)){
fscanf(fp, "%d %s %s %s %s %s %c\n", &uj->szint, tempk, tempa, tempb, tempc, tempd, &uj->valasz);
uj->ker=(char*) malloc(strlen(tempk)*sizeof(char));
strcpy(lista->ker,tempk);
uj->a=(char*) malloc(strlen(tempa)*sizeof(char));
strcpy(lista->a,tempa);
uj->b=(char*) malloc(strlen(tempb)*sizeof(char));
strcpy(lista->b,tempb);
uj->c=(char*) malloc(strlen(tempc)*sizeof(char));
strcpy(lista->c,tempc);
uj->d=(char*) malloc(strlen(tempd)*sizeof(char));
strcpy(lista->d,tempd);
uj->kov=lista;
lista=uj;
}
}
fclose(fp);
return lista;
}és így hívnám meg main-ben:
Kerdes *lista=NULL;
beolvas(lista);Hiba nélkül lefut, de amint elindul, le is fagy. Mi lehet a gond?
(életem első fájlból olvasása lenne C-ben. korábban csináltam már C#-ban, de ott ugye nem kellett a dinamikus dolgokkal szórakozni. amúgy azt az infót kaptam, hogy ha így elszáll, akkor az pointerek miatt van, de fogalmam sincs hogy hol.) -
#42308056
törölt tag
Sziasztok!
Félévi feladatot csinálok suliba, de elakadtam. Az az alapvető probléma, hogy külső fájlból szeretnék adatokat beolvasni, de amíg nincs létrehozva a külső fájl hibát dob (segmentation fault (core dumped)).
Van valami megoldás arra, hogy amíg nincs külső fájl addig ugorja át a beolvasást? Egy if-fel esetleg lehet-e ellenőrizni hogy megvan-e ez a fájl, vagy valami hasonló egyszerű dolog?
Ha más ötletetek van arra is vevő vagyok, csak értsem is (nem vagyok nagy c guru).
-
tototos
addikt
Sziasztok!
Egy újabb érdekes esettel fordulok hozzátok.
A split függvény helyett, egyik kollégám ajánlotta a sscanf függvényt, ami nekem pont tökéletes, lenne ha működne úgy ahogy szeretném.Adott a következő char[80] line = "48,8,10;\n\000\000age\000\070\000\060\000;\n\000\000;\n\000\000;\n\000\065,51;\r\n21,52;\r\n1, ..."
ebből s zámomra szükséges rész az ez: 48,8,10;\n\0
na ezt szeretném beolvasni így:
ret = sscanf(line,"%hhu%*1c%hhu%*1c%hhu;\n",&frameID,&frameLength,&frameDelay);
a ret értéke 3, de a frameID és a frameLength 0 a frameDelay az 10.Már próbáltam többféle képpen de egyszerűen nem akar jó lenni :S
-
-
buherton
őstag
válasz
tototos
#4249
üzenetére
Az a baj a dinamikus memória használattal, hogy MPU nélkül nincs ki töredezettségmentesítse a memória táblát, és így előbb utóbb jön a hard fault exception, és jöhet a fej vakarás, hogy most ez mi a bánat volt, mert az RTOS-ek nem arról híresek, hogy szájbarágósan leírja, hogy mi történt (tapasztalat). Azt szokták csinálni, hogy előre lefoglalnak x memóriát, és arra írnak egy vezérlőt, ami karbantartja azt a területet, és ha kell akkor neked pointert, de ennek a technikai részletét nem ismerem. De mondom használj auto változót, vagy hát ha valaki másnak van jobb ötlete.
-
tototos
addikt
válasz
buherton
#4248
üzenetére
Köszi
Nem tudtam hogy ennyire tiltott. Azt tudtam hogy beágyazott környezetben kb halál, de most szükségem lenne rá sajnos.Van az oprendszerben saját heap kezelő. Sajnos ez is kiakad egy ponton. Amikor fel akarom szabadítani a char** változót.
Megnéznétek a kódot, hogy biztosan jól használom a dolgokat? Sajnos valami programozási hibára gyanakszom. -
buherton
őstag
válasz
tototos
#4245
üzenetére
Milyen mikrokontrollerről van szó? Van benne MPU? Ha nincs, akkor a malloc/free használata teljes öngyilkosság, és borítékolható a fagyás. Ha auto változóba tárolod le a stringet, akkor azt stackre rakja, ha jól rémlik.
MPU nélküli MCU-kban is lehet dinamikus memóriákat foglalni, de ahhoz neked kell a kezedbe venned a memória menedzsmentet. A mi projektünkben a kommunikációs driver pont így működik.
-
tototos
addikt
Sziaszto!
Egy érdekes problémával állok szembe. C-ben szeretnék stringeket darabolni. Ez egyenlőre nem tűnik nagy feladatnak, van egy függvényem ami szépen darabolja a dolgokat. A gond ott kezdődik, hogy amikor fel akarok szabadítani a feldarabolt részeknek allokált területet akkor egyszer a free függvény váratlan hibát generál és a mikrovezérlőm elmegy egy végtelen ciklusba.
EZ lenne a daraboló függvény:
char** str_split(char* a_str, const char* a_delim)
{
char** result = 0;
size_t count = 0;
char* tmp = a_str;
char* last_comma = 0;
size_t index;
/* Count how many elements will be extracted. */
while (*tmp)
{
for (index = 0; index < strlen(a_delim); ++index)
{
if (*(a_delim+index) == *tmp)
{
count++;
last_comma = tmp;
}
}
tmp++;
}
/* Add space for trailing token. */
count += last_comma < (a_str + strlen(a_str) - 1);
/* Add space for terminating null string so caller
knows where the list of returned strings ends. */
count++;
result = malloc(sizeof(char*) * count);
if (result)
{
size_t idx = 0;
char* token = strtok(a_str, a_delim);
while (token)
{
assert(idx < count);
*(result + idx++) = strdup(token);
token = strtok(0, a_delim);
}
//assert(idx == count - 1);
*(result + idx) = 0;
}
return result;
}Ez pedig egy része a kódnak:
tokens = str_split(line, ",;");
if (tokens)
{
LINScheduleTable[frameIndex].Frame.SignalIDs_lda16[signalIndex] = atoi(*tokens);
LINScheduleTable[frameIndex].Frame.SignalOffsets_lda8[signalIndex] = atoi(*(tokens+1));
for (i = 0; *(tokens + i); i++)
{
free(*(tokens + i));
}
free(tokens);
}Az érdekesség, hogy ez a részlet meghívódik kb 25-ször, és 26. lépésnél száll el.
Láttok valami hatalmas hibát a kódban?Köszi
-
Karma
félisten
válasz
tototos
#4241
üzenetére
Ha törölni akarod azt a szakaszt, akkor ÉSelned kell egy olyan számmal, ami a kívánt bitszakaszon 0, körülötte 1. Ha beállítani, akkor meg VAGYolnod kellegy olyannal, ami a szakaszon 1, mindenhol máshol 0.
Pl. 01010101 & 11100011 = 01000001,
Ill. 01010101 | 00011100 = 01011101Persze az előbbi megoldás teljesebb, mert a maszkot is megcsinálja és konkrét értéket is tud
-
-
tototos
addikt
válasz
Jester01
#4238
üzenetére
Köszi.
Melyik a jobb megoldás ha veszek egy 64 bites változót, és ebbe rakom be az adatokat, majd ezt bájtokra bontva elküldöm, vagy az ha a tömbbe rakom be a fenti módszerrel az adatokat és a tömböt küldöm ki?
Ugyanezt kell visszafele is, tehát van egy uint8_t tömb[8] tömb, amiből ki kell nyernem az adat pozíciótól az adott hosszú adatokat.@dabadab: Bájtosával kell kiküldenem az adatokat, és úgy is kapom őket. Tehát vagy alapból bájt tömbben tárolom őket, vagy a 64 bites változómat darabolom bájtokra, valamint vételnél visszafele.
-
-
tototos
addikt
válasz
dabadab
#4234
üzenetére
Köszi.
Hát most végül működik 64 bites változóval de nem tudom mennyire optimális.
Ez az amikor kiveszek egy tömbböl elemeketuint8_t LINReceiveBuffer[8];
LINScheduleTable[ScheduleTableIndex].LINScheduleTableFrame.LINFrameValue = 0;
for (Index = 0;Index < ResponseDataByteIndex-1;Index++)
{
LINScheduleTable[ScheduleTableIndex].LINScheduleTableFrame.LINFrameValue += (LINReceiveBuffer[Index+1] << ((LINScheduleTable[ScheduleTableIndex].LINScheduleTableFrame.LINFrameDataLength - 1 - Index)*8));
}Ezzel rakom be:
if (ResponseDataByteIndex < LINScheduleTable[ScheduleTableIndex].LINScheduleTableFrame.LINFrameDataLength)
{
DataCheck = (uint8_t)(LINScheduleTable[ScheduleTableIndex].LINScheduleTableFrame.LINFrameValue >> (LINScheduleTable[ScheduleTableIndex].LINScheduleTableFrame.LINFrameDataLength - 1 - ResponseDataByteIndex)*8);
LINChecksumBuffer[ResponseDataByteIndex+1] = DataCheck;
USART_SendData(USART6,DataCheck);
ResponseDataByteIndex++;
} -
dabadab
titán
válasz
tototos
#4233
üzenetére
mennyire jo megoldasod van?
en valami ilyesmit csinalnek:
uint16 array[4];
void insert(uint16 value, uint address)
{
uint pos;
uint shift;
pos = address >> 4;
shift = address & 0x0f;
array[pos] = value << shift;
array[++pos] = value >> ( 0x0f - shift);
}Mondjuk ezt erosen endian-fuggo, szoval inkabb at kellene irni unit8-as tombre, de a lenyeg ez, meg kinullazza a byte-ok szelet, szoval ott valami maszkolni meg orozni kell, ha ez baj.
-
tototos
addikt
Sziasztok!
Egy kis segítwséget szeretnék kérni.
Adott egy maximum 8 bájtos tömböm, amibe maximum 16 bites változókat szeretnék beszúrni bizonyos bitpozíciókra. A bitpozíciók a nyagságból adódóan 0-tól 63-ig lehetnek számozva. Az első megoldásom az lett volna hogy a tömb helyett használok egy 64 bites változót de ennek a kezelését nem támogatja az eszköz. Tudnátok erre a problémára valamilyen optimális megoldást mondani?
Köszönöm
-
buherton
őstag
válasz
skylaner
#4230
üzenetére
A fejlesztőt védeni kell az ilyenektől, mert ha meg van a lehetőség a bakira, akkor a fejlesztő élni fog vele, és fog ilyen hibát véteni. Ahogy lehet látni az error exceptionokon, és rengeteg memory leak-en, és nem véletlenül retteg mindenki az optimazációs szint lépéstől
, mert ilyenkor jobban összébb csúsznak a memóriában a dolgok, és igen hatékonyan eltudja rejteni a memória túl írásokat. A memcpy-nál meg tudod adni a méretet.Nálunk új függvényeket csináltak erre, amivel biztosítva van, hogy a string mindig nullával végződik, így egy rakat hiba lehetősétől mentjük meg magunkat, de ettől függetlenül a hossz miatt még mindig vannak elírások akaratlanul is. Egy ilyen memória elírásnak a megkeresési ideje lehet 5 perctől 1 hétig terjedő idő, mert nálunk az OS nem árul el sokat, arról hogy hol történt a probléma.
-
dabadab
titán
válasz
skylaner
#4230
üzenetére
"Dehát ez nem az strlen hibája."
De. Nem veletlenul talaltak ki az strnlen()-t.
"Most azért ne használjak egy már megírt fgv-t mert lehet, hogy hibás paraméterrel hívom meg?"
Igen, foleg ilyen esetekben, ahol a parameter jo esellyel nem magabol a programbol, hanem inputbol szarmazik, mivel ezzel hatalmas kaput nyitasz a buffer overflow exploitoknak.
"Tessék gondoskodni arról, hogy helyes paramétert adunk át a fgv-nek."
Hat, ha 100%-ra meg tudsz eskudni arra, hogy az strlen csak es kizarolag rendesen null-terminated stringet kap (es ha barhol, barmikor, barki megvaltoztat valamit a programban, ami miatt ez majd nem all fenn, akkor abban a pillanatban lecsereled), akkor csinald, de nekem joval egyszerubbnek tunik az strnlen() hasznalata.
-
skylaner
senior tag
válasz
buherton
#4227
üzenetére
Dehát ez nem az strlen hibája.
Most azért ne használjak egy már megírt fgv-t mert lehet, hogy hibás paraméterrel hívom meg?
A fejlesztő feladata és felelőssége, hogy helyesen használja a fgv-ket.
Most akkor a memcpy se használjuk mert lehet, hogy a source adatszerkezet kevesebb byte-ból áll mint amit a 3. paraméterben megadtunk?Szerintem nem jó amit mondasz.
Tessék gondoskodni arról, hogy helyes paramétert adunk át a fgv-nek.
Az strlen() teljesen jól van megírva. -
buherton
őstag
válasz
Dave-11
#4223
üzenetére
Ezzel már letárolod a memóriában a tömböt: "Szia!", erről nyugodtan lehet kérni pointert, ahogy függvény argumentumként szokták is csinálni, de csak megkötésekkel.
1 év PERL után tértem vissza a C-re, és nagyon felidegesítettem magam, hogy mi a hét szentségért nem hajlandó benyelni a fordító ezt: char foo[10]; foo = "bar";
strncpy, és strncmp függvényeket használd, és figyelj mindig a \0 karakterre. Az strlen-t pedig kerüld amennyire tudod.
(#4224) Korcsii:
arra a MasterCard való . -
Dave-11
tag
Van az alábbi kódom:
char *c = malloc(sizeof (char) * 5);
Tehát lényegében ezzel létrehoztam egy karaktertömböt. Ennek az értékét akartam megadni, majd kiíratni az alábbi módokon, de nem jött össze:
Két módszer az értékek megadására:
1. c = "Szia";
2. *c = "Szia";
Az 1. megoldást gondoltam hogy nem jó, mert ugye pointernek hülyeség értéket adni, az ugye csak a memóriacímet tudja tárolni.
A 2.-ban már bíztam, mert ugye a * operátorral visszamutatok a karaktertömbre, és úgy próbáltam megadni az értékét (mint hagyományos módon: char c[] = "Szia";)
Aztán ha esetleg működött is az előző, a printf()-el nem tudtam kiíratni sehogy.
Próbáltam így is: printf("%s",c); meg így is: printf("%s",*c); de mindkét próbálkozásnál kifagyott a program.
Szerintetek mi lehet a hiba? -
buherton
őstag
Áh értem most már.
(#4219) alapz@j: Nem op.rendszer függő, hanem architektúra. Az általunk használt ARM nem támogatja az MPU-t, így ha dinamikusan foglalsz memóriát, majd szabadítasz fel, akkor egy idő után teljesen széttöredezik a memória tábla, és lefagy az egész. De ha támogatná sem lehetne használni, mert automotive.
-
Karma
félisten
Gyanús hogy azért nem fogadta el, mert azt akarta, hogy kézzel implementáld le ugyanezt. A helyszínen kellett volna kifejtetni vele az ítéletét.
Az oldalon lévő szöveg is csak annyit mond, hogy lassú lehet – de ez éppúgy igaz arra is, ha kézzel mallocolsz nagyobb területet, átmásolod memcpyval, és felszabadítod az előzőt.
A kulcsmondat igazából ez: "Ne írjunk olyan programokat, amelyek gyakran méreteznek át tömböket!"
A szabvány alapján nincs arra garancia, hogy ha kisebbre reallocolsz, akkor nem fogja mozgatni a memóriát. Mindenképpen le kell kezelned a visszatérési értéket helyesen, azaz nézni a NULL választ, és nemNULL esetben kicserélni az előzőt siker esetén; ha fel-, ha leméretezel.
-
v2izzy
tag
Én sem értem. Ha valakit érdekel itt van a slide, ahol felhívják a figyelmet erre. Leginkább a gondom amúgy az volt, hogy egy beadandónál nem fogadta el az oldal a programomat, mert szerepelt benne a realloc szó.
Még ezekkel kapcsolatban lenne olyan kérdésem, hogy ha meghívom realloc-ot, hogy kisebb memóriaterületet foglaljon, akkor levágja a lefoglalt területet? Ha igen, akkor mindig vagy ez függhet más dolgoktól?
-
Karma
félisten
válasz
buherton
#4217
üzenetére
"Szerintem azért, mert sokan elfelejtik, hogy a realloc-nak a visszatérési értékét kell odaadni a pointernek."
Pont ezt nem szabad csinálni azelőtt, hogy megnézné az ember hogy NULL-t adott-e vissza a realloc – mert ha igen, akkor elveszted az eredeti memóriaterületet.
Ettől függetlenül se a realloctól, se a calloctól való félelmet nem értem az oktatásban, bár lehet hogy anno megmagyarázták; én meg elfelejtettem.
-
buherton
őstag
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.
-
v2izzy
tag
Hello!
Megkérdezhetném, hogy mi a gond a realloc függvénnyel? Miért nem tanácsos használni?
Mert az egyetemem úgy tűnik eléggé ellenzi.
Azt értem, hogy nem szerencsés sokszor meghívni (tehát pl minden új elemre egy tömbnél újraméretezni), mert ugye lehet hogy az egész területet át kell másolja. De pont olyan feladatot adtak ki, ahol le van írva, hogy minden új elemre növelni kell a tömb méretetét.
Így most kb. ugyanazt írom meg mint a realloc, csak éppen azt sem tudom megnézni, hogy van-e a memóriában hely a lefoglalt terület előtt... -
#4214
Bobrooney
senior tag
neil_mullen
#4213
Bobrooney
senior tag
válasz
neil_mullen
#4213
üzenetére
rakj sortörést az fprintf-be
fprintf(file1,"%f\n",d);Mellesleg minket suliban óva intettek az fscanf használatától. fgets-el kérd be majd sscanf-el jobban le tudod kezelni. // Nekünk így mondták és látok is benne rációt.
-
#4213
neil_mullen
aktív tag
neil_mullen
aktív tag
Sziasztok!
A problémám az lenne hogy c-ben elakadtam az fscanf használatánál. Egy file-ba irtam 138 db számot, 'k' a kezdőérték, 0.25-tal csökkentve. Ezt float-ban irtam ki (fprintf) és float-ban is olvastam vissza (fscanf). És hát a baj az hogy az első számot még jól olvassa be
de a többinél "levág" az elejéből. Előre is köszi a segítséget.#include <stdio.h>
#include <stdlib.h>int main()
{
FILE *file1;
char a='k';
int c=0;
double b, d;
file1=fopen("adat.txt","w+");
if(file1==NULL) printf("hiba");
while(c<138)
{
b=(double)(a);
d=b-(c*0.25);
fprintf(file1,"%f",d);
c++;
}
fclose(file1);FILE *file2;
file2=fopen("adat.txt","r");
if(file1==NULL) printf("hiba");
char f;
float e=0;
while(!feof(file2))
{
fscanf(file2,"%f",&e);
printf("%f\n",e);
//f=(char)(e/1);
}
fclose(file2);
}
-
daneel92
tag
sziasztok!
restellem, hogy ilyenhez kell folyamodnom, de tudnátok segíteni programozás háziban? holnap van a leadási határidő, és marhára nem értem a témát. két feladatból áll. az egyik ez:
Írjon egy programot amely, létrehoz egy két dimenziós tömböt (mátrixot), tölti a mátrixot véletlen értékű elemekkel, és írja ki a tömböt klasszikus mátrix formában, utána még egyszer írja ki a mátrixot de a sorokból csinál oszlopokat és az oszlopokból csinál sorokat. Programja kalkuláljon a 3. sor és a 4. oszlop elemeinek az összegét.
a másik ez:
Írjon egy programot amely, megoldja egy lineáris egyenletrendszert.
Igazából magát a mátrix témakört nem értem, hogy az olyanokat, mint invertálás hogyan tudom megvalósítani c-ben. -
aAron_
őstag
megint egy hülye kérdésem lenne a codeblocks-al kapcsolatban, valaki meg tudná mondani, hogy lehet kikapcsolni a kommentek helyesírás (?) ellenőrzését? most mindent szép piros hullámos vonallal aláhúz nekem, elég idegesítő hosszú távon, mert nehezíti a gyors olvasást.
nem is értem, legutóbb semmit nem kellett ilyenekkel vackolnom, most meg a angol hotkeyektől kezdve minden nevetséges hülyeséggel szívok.
-
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"); -
dabadab
titán
válasz
Jester01
#4205
üzenetére
Kenytelen vagyok visszakozni: megtakaritana, mivel itt csupa char lenne. Ha amugy egy csomo intje meg pointere lenne, es akoze rakna be egy-egy chart, akkor nem lenne megtakaritas, mert ott azoknak a 4 / 8 byte-os alignmentje bekavarna, de ha tenyleg mindenki char, akkor nincs ilyen gond.
-
dabadab
titán
válasz
skylaner
#4202
üzenetére
Mivel defaultban ugyis aligned az egesz, igy aztan abszolut semmit nem takaritasz meg azzal, hogy chart hasznalsz, csak egy plusz korlatot vezetsz be, ami aztan a kesobbiekben problemassa valhat (ugyanez vonatkozik az unsigned-ra is).
Es ha mar kapcsos zarojelek: igazabol erdemes mindig kirakni oket, szemleltetem.
Kiindulasi allapot:
for(i=0;i<n;i++)
if (palyak[i]==0)
{
nemsi_index[a]=i;
a++;
}Aztan az ember debuggol:
for(i=0;i<n;i++)
DEBUG("qweqwe");
if (palyak[i]==0)
{
nemsi_index[a]=i;
a++;
}Es maris kesz a katasztrofa, amihez raadasul az IDE-k boldogan asszisztalnak (true story
). -
#4202
skylaner
senior tag
stranger28
#4193
skylaner
senior tag
válasz
stranger28
#4193
üzenetére
Szia!
Én annyit tennék hozzá, hogy mivel 0-tól 100-ig fogsz számokat tárolni így felesleges memória pazarlás int-et használni.
unsigned char *palyak;Illetve a többi változó is lehetne char/unsigned char.
De minden kezdet nehéz ugyebár.
Így utólag elég hülyének érzem magam.
Amúgy az érdekesség, hogy vannak olyan sorok ahol csak 2 szám van, ott tökéletesen működik.
, vagyis éppen elérhető, de önmagában nem csinál semmit. AMúgy futottam már ilyenbe, és ha nincs rá debug akkor tud érdekes dolgokat csinálni.
arra a MasterCard való 
).
Új hozzászólás Aktív témák
Hirdetés
● olvasd el a téma összefoglalót!
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- Bomba ár! HP EliteBook 820 G2 - i5-5GEN I 8GB I 256GB SSD I 12,5" FHD I Cam I W10 I Garancia!
- 100.000 ft -tól Országosan a legjobb BANKMENTES részletfizetési konstrukció! ASUS ROG Strix G18
- BESZÁMÍTÁS! MSI B450M R5 5500 16GB DDR4 512GB SSD RTX 2070 8GB Rampage SHIVA FSP 650W
- Bomba ár! Dell Latitude E6500 - Intel P8600 I 3GB I 160GB I DVDROM I 15,4" WXGA+ I Garancia!
- Telefon felvásárlás!! Samsung Galaxy S25, Samsung Galaxy S25 Plus, Samsung Galaxy S25 Ultra
Állásajánlatok
Cég: PC Trade Systems Kft.
Város: Szeged
Cég: CAMERA-PRO Hungary Kft
Város: Budapest