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.

Ezt tapasztaltam én is.

Uraim!

El vagyok keseredve.
Jó 10 év után újra elővettem a C-t, gyorsan átfutottam pár nap alatt az egészet és arra kellett rájönnöm, hogy valahol elhagytam az agyam, mert akkoriban még egész jól ment, most meg alapvető dolgokat nem értek. Persze az is lehet, hogy mindig is hülye voltam, csak akkoriban nem jöttek elő ezek a kérdések... nem tudom, mindenesetre segítséget kérek, mert magamtól nem megy és a google sem a barátom ezekben (és még egy rakás másban sem, de most ezek jutottak hirtelen eszembe):

1. Van egy olyanom, hogy

int a = 1, b = 1, d = 1;

printf("%d, %d, %d", ++a + ++a + a++, a++ + ++b, ++d + d++ + a++);

Kérdés, hogy mit ír ki? A megoldás: 15, 4, 5. De miért?

2. Legyen egy long int-em:

long int li = 12345L;
Miért kell nekem az 12345 végére az L betű? A fordítónak jelzem, ha nem lenne elég, hogy odaírom, hogy long? Saját magamnak jelzem, nehogy elfelejtsem a típust? Egyéb?

3. scanf és az ő filterezése.
Elvileg lehet olyat, hogy scanf("%[0-9a-fA-F]", &akarmi), hogy csak számokat és a-f / A-F karaktereket olvashasson be. Nekem mégsem megy, sem a komplementer változata ^0-9... verzióban. Mit rontok el?

4. Pointeres változók.
Miben különbözik az int* i és az int *i ? Van egyáltalán bármi? Mondjuk ezt közben pont megtaláltam, miközben írtam, úgyhogy sztornó (a válasz itt)

5. enum-ok.
Legyen két felsorolásom:
enum birds {SPARROW, PEACOCK=5, PARROT};
enum animals {TIGER = 8, LION, RABBIT, ZEBRA};

enum birds m;
m = LION; //Ezt elvileg nem lehetne, de mégis lehet. Miért?
Szóval én eddig azt hittem, hogy ha van egy enum típusú változóm, akkor azokat az értékeket adhatom neki, amik a felsorolásban szerepelnek, de úgy tűnik, mégsem. Valahol elvesztettem a fonalat.

+1. Nagybetűsíteni szeretnék egy stringet egy függvénnyel: megkapni paraméterben és visszaadni a nagybetűs verzióját. Erre több megoldás is lenne, de valahogy egyik sem az igazi:

- valamiért nem viszi a sima strupr()-t, ráadásul az az eredeti változót változtatja meg, ami nem oké. Csinálnék helyette egy másikat, de vagy kell hozzá globális változó, vagy nem ideális a memóriafelhasználás, vagy megváltoztatja az is az eredeti paramétert... Hogy kéne ezt normálisan?
Amikkel próbálkoztam, azok ezek:

void upper_string(char *string)
//Ez már megy, de ez is megváltoztatja az eredeti paramétert, ugye.
{
while(*string)
{
if ( *string >= 'a' && *string <= 'z' )
*string = *string - 32;
string++;
}
}

Lehetne olyan, hogy:

char* upper_string2(const char *string)
{
int i=0;

/*
Namármost. Vagy definiálok egy globális char copystr[]=""; változót és annak a címét használom,
vagy definiálunk itt egy olyat, hogy char copystr[(strlen(string)]=""; , ami viszont lokális változó,
és nem jó ötlet lokális változó címét visszaadni a függvényen kívülre; vagy csinálunk egy static változót
itt helyben, aminek viszont méretet kell adni, amit nem lehet csak úgy strlen-nel. Én ezt az utóbbit választom, mondjuk 255-ös hosszal, de hát ez is milyen már.
*/

static char copystr[255]; //Lehetne ez [65535] is akár.
strcpy(copystr, string);

while(string [ i]!='\0')
{
//Csak a kisbetuket valtoztatjuk, a tobbi marad
if ( string(i) >= 'a' && string(i) <= 'z' )
copystr(i) = string(i)-32;
i++;
}
return copystr;
}

Vagy lehetne simán ez is, de ez is megváltoztatja az eredeti változómat:

char* upper_string3(char str[])
{
int i=0;

while(str(i) !='\0')
{
if ( str(i) >= 'a' && str(i) <= 'z' )
str(i) = str(i)-32;
i++;
}
return str;
}

Szóval van baj, nem tudom, hogy mikorra állnak vissza a fejemben a dolgok, de elkelne egy kis segítség.

[ Szerkesztve ]

1.
Ezt ne is próbáld megfejteni, mert unspecified az inkrement és dekrement kiértékelési sorrendje ilyen esetekben.

2.
Nem szükséges az L, mert a fordító castolni fogja, de ajánlott, mert így szép.

3.
Ilyenekkel ki lehet kergetni a világból . Az elmúlt 4 évben egészen biztosan nem írtam le még gondolatban sem a scanf-t .

4.
Nincs különbség. Az utóbbit ajánlatos használni, mert nem típus, hanem a változó lehet pointer.

5.
Lehet, mert az enum egy számot reprezentál, viszont nem ajánlatos íly módon használni, mert nagyon megtudja keverni az embert.

+1.
Erre van egy uppercase vagy milyen standard függvény.

[ Szerkesztve ]

tely, baly, fojó, mennyél, mingyárt, telyföl, tolyás, malyd, kapú, egyenlőre, ejsd, jáccani, ahoz, fúj, hüje, muszály, alat, álok, lasan, fojtatás, ál, fontós, költsön, eggyüt, lyob (jobb?), mek, mongyak, milyért - !!! Tanúlyunk már meghejjessen irni... !!!

Az előző végén persze nem figyeltem és átváltoztatta nekem a [ i ] -jeimet (i)-re meg jó kis dőlt betűre, szóval az utolsó rész még egyszer:

static char copystr[255];
strcpy(copystr, string);

while(string[ i ] !='\0')
{
//Csak a kisbetuket valtoztatjuk, a tobbi marad
if ( string[ i ] >= 'a' && string[ i ] <= 'z' )
copystr[ i ] = string[ i ]-32;
i++;
}
return copystr;
}

illetve

char* upper_string3(char str[])
{
int i=0;

while(str[ i ] !='\0')
{
if ( str[ i ] >= 'a' && str[ i ] <= 'z' )
str[ i ] = str[ i ]-32;
i++;
}
return str;
}

1. nem lehet tudni mit ír ki, mert nem definiált működés
2. itt nem kell az L, akkor kellene esetleg ha műveleteket végzel vele ami túlcsordulhat
3. nem tudjuk ennyiből megállapítani
5. a C ilyen buta
+1. ha nem az eredetit akarod módosítani, akkor foglalj dinamikusan memóriát (malloc)

buherton:

[ Szerkesztve ]

Jester

Wow, ez gyors volt.
Az 1.-nél hasonló gondolatra jutottam én is, aztán negyed óra anyázás után szétszedtem külön átmeneti változókra, de azért izgatja a fantáziámat... ami könyvet meg fellapoztam, mind csak az egyszerűbb részeket mutogatta, ++i, i++, aztán annyi.

2. Pöpec. Megcsinálni szívesen megcsinálom, ha így szokás, csak zavar, ha nem tudom az okát.

3. Mivel lehet akkor jól beolvasni a usertől mindenfélét? Illetve ha már itt vagyunk, akkor eszembe jut a getchar is, hogy a Jóistennek sem sikerül beolvastatnom vele egy Entert vagy Escape-et (mondjuk hogy arra kilépjen) - q-t igen, vagy más szép karaktert, de ezeket nem szereti.

4. Volt ennek valami furább verziója, talán int *const p / int const* p / const int* p / int const * const p, de ez is közben tisztázódik az órajárásos megoldással, szép lesz ez.

5. Kár, pedig szép lenne egy beépített szűrő

6. Utánakeresek akkor.

Köszönöm ezt is.

2. Akkor ezek szerint gyakorlati haszna is van.. akkor mindenképpen odaírom.

A scanf-nél mondjuk ha az lenne a feladat, hogy csak számokat olvashat be, akkor mit kéne tennem? Vagy ne használjam a scanf-et, hanem mondjuk while-lal addig kérjem be a dolgokat, amíg megfelelő inputot nem kapok?

mallocnak utánaolvasok azonnal.

Screenshot

Screenshot

Elhittem én elsőre is. Csak leírtam, nálam mi volt a kínja. Fura.

És ha előtte átváltod a konzol karakterkódolását szabvány ansi-ra?

chcp 1250

Akkor nem jól jelennek meg az ékezetek a konzolban.

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.

[ Szerkesztve ]

Sziasztok,

Nem tudom megoldani azt, hogy csak akkor olvasson be egy karaktert az stdin-ről, ha van karakter, magyarul ne várjon a karakterre, ha nincs.

while (1) {
if (checkInput()) doInput();
if (checkTimer()) doTimer();
}

nos azt hiszem, sikerült megoldanom a problémát:

void ???func(void *parm) {
pthread_mutex_lock(&mutex);

...

pthread_mutex_unlock(&mutex);
sched_yield();
return NULL;
}

int main(int argc, char **argv) {
pthread_t threadid, inputid;
char f;

f = 1;
while (1) {
pthread_mutex_lock(&mutex);
pthread_create(&threadid, NULL, threadfunc, NULL);
if (f) {
f = 0;
pthread_create(&inputid, NULL, inputfunc, NULL);
}
usleep(10);
pthread_mutex_unlock(&mutex);
pthread_join(threadid, NULL);
pthread_mutex_destroy(&mutex);
}
}

ahol az inputfunc a doInput() és a threadfunc a doTimer()

Magyarul, két külön szálon fut a két funkció.

A program alapját a neten találtam, és egyenlőre fogalmam sincs, hogy a pthread_xxx-ek mit is csinálnak pontosan, de a program az elvárásoknak megfelelően működik.

[ Szerkesztve ]

Ja, megoldani mi is meg tudjuk, ennél egyszerűbben is. Csak szabvány C-ben nem. A pthread az nem az.

Jester

Sziasztok,

újra gondom van, pontosabban egy régi dolog jött fel újra.
Egyszerű a feladat: 1 és 5 közötti számokat kell beolvasnom. Azt gondoltam, hogy megoldom ezzel:

#include <stdio.h>


int main() {

int i;

do
{
printf("Adjon meg egy szamot 1 es 5 kozott:\n");
scanf("%d", i);
fflush(stdin);

if ((1>i) || (5<i)) printf("A megadott adat nem 1 es 5 kozotti szam.\n");

} while ((1>i) || (5<i));

printf("A megadott szam: %d\n", i);

return 0;
}

A program megy, ha mondjuk 4-et ütök be. Működik akkor is, ha mondjuk 44-et ütök: kiírja, hogy hibás és újra kéri. De ha nem számot ütök be, hanem mondjuk egy k betűt, akkor végtelen ciklusban elkezdi kiírni, hogy "Adjon meg egy szamot 1 es 5 kozott:
A megadott adat nem 1 es 5 kozotti szam." ,

Mindezt beolvasás nélkül, hiába az fflush.

Kérdés, hogy mit nézek el? Hogyan kell normálisan bekérni 1 és 5 közötti számokat?

(A scanf("%d", i); igazából scanf("%d", &i); valamiért most lemaradt az &. )

A beolvasás egyszerű feladatnak tűnik, mégis meglepően bonyolult jól csinálni.

Az fflush(stdin) nem szabványos, vagy működik vagy nem. Az ajánlott módszer teljes sorok olvasása fgets használatával, majd a beolvasott sor számmá alakítása strtol segítségével. A helyes megoldás a sor olvasásnál kezeli a túl hosszú sorokat, és az átalakítás után ellenőrzi, hogy maradt-e még feldogozatlan karakter.

Ennél egyszerűbb megoldás, ha az fflush(stdin) helyett egy fgetc(stdin) ciklussal kiolvasol mindent a sor (vagy a bemenet) végéig.

Az is rossz a kódban, hogy a scanf visszatérési értékét nem ellenőrzöd. Ha ugyanis nem számot írnak be, akkor nem tud mit konvertálni és az i értéke változatlan marad. Azt pedig nem is inicializáltad, tehát bármi lehet. Ha véletlenül 1 és 5 közé esik akkor a programod kilép a ciklusból.

[ Szerkesztve ]

Jester

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?

Előszöris az igazzy C programozó, valamiféle Unix féle rendszert használ, természetesen c-shellel

De komolyra fordítva a szót. Szerintem először célszerű átlátni hogy a programozás egyes fázisaiban mi is történik, milyen programokat és miért kell futtatni. (szerkesztés, fordítás, futtatás, hibakeresés) Ezeket a részleteket az integrált fejlesztői környeztek jól eltakarják, ezzel "egyszerűsítve" a programozást.
Szóval az IDE-k használata (pl. Dev-C, Code-Blocks, Visual Studio, Netbeans, Eclipse) szerintem csak akkor jó ötlet ha tudod mi történik és hogyan. Ha ez a lépés kimarad akkor nagyon sok minden bonyolultnak, érthetetlennek tűnhet.

Később valamelyik professzionális IDE megismerése mindenképp javasolt. Én az Eclipse mellett döntöttem, de van más lehetőség is.

"Nem gond ha nem vágod a párologtatók bináris nyelvét..."

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).

Tapasztalatból mondom, hogy a Cygwin Eclipse páros nagyon sok szenvedést okoz.

Ha Linuxra akarsz fejleszteni, akkor virtualbox vagy tedd fel natívba. Ha ragaszkodsz a GCC-hez, akkor min-gw + Eclipse, viszont ekkor windows-os környezetet kell haszálnod.

tely, baly, fojó, mennyél, mingyárt, telyföl, tolyás, malyd, kapú, egyenlőre, ejsd, jáccani, ahoz, fúj, hüje, muszály, alat, álok, lasan, fojtatás, ál, fontós, költsön, eggyüt, lyob (jobb?), mek, mongyak, milyért - !!! Tanúlyunk már meghejjessen irni... !!!

bucsupeti, alapz@j, buherton:

Köszönöm az infókat. Kipróbálom őket, aztán kiderül - egyelőre mondjuk csak egyszerű, banális kis jószágokat gyártok, amihez akár egy online fordító is oké, csak a lépésenkénti futtatást / debugot hiányolom különösebben, hogy jobban lássam, hogy éppen mi történik.

C-ben írt programom lassan testet ölt... pár kép róla:

KB. 3 hónapos fejlesztés eredménye kezd körvonalazódni..
Ha nem látszana akkor elmondom, hogy ez egy levegős forrasztó gép amelynek a vezérlését C-ben programoztam le..
Nem szorosan tartozik ide, de mivel sokat tanultam tőletek szívesen mutatom meg miket készítek..
Remélem nem veszitek zokon...

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Uraim...
Van egy kis problémám.
Van egy programmemóriába létrehozott tömböm és ebből szeretnék kiíratni.
A következő képen néz ki:

rom static unsigned char szovegek[14][19] = {
{'P','r','o','f','i','l',' ','n','e','v',':'} //, ...stb sorok
};
//A kiíratást meg így
printf("%s", szovegek[i]);

Az i természetesen növekszik.
Ha nem a rom-ba teszem hanem simán a memóriába akkor menne, de akkor meg a hely kevés..
Azért van szükség erre a tömbre mert szeretnék helyet spórolni...
Előtte switch() elágazással csináltam, de az zabálja a memóriát.
Előre is köszi...

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Oo, nem kene 0-val terminalni a sztringet? Egyebkent mit jelent az, hogy 'nem megy'?

while (!sleep) sheep++;

Nem ír ki semmit.
Ha nem a ROM-ba teszem akkor meg simán kiírja a tömb tartamát.

Tehát így kiírja a tartamát:

static unsigned char szovegek[14][19] = {
{'v','a','l','a','m','i',' ','h','e'}
}
printf("%s", szovegek[0]);

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Közben megoldódott a probléma..
Nagyon egyszerű volt és ezért volt nehéz
Álljon itt a példa:

printf("%s", valtozo[0]); //kiíratás sima srting egy tömbből
printf("%S", valtozo[0]); //kiíratás program memóriában tárolt (ROM) srting egy tömbből
l
Ennyi .. az a fránya "%S"...

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Hali!
Nagyon alapszintű c++-os problémám akadt, többszöri átnézés után sem kapom a hibát.
Nem is csúfítanám a fórumot vele, aki tudna ésvagy hajlandó rápillantani a kódra az írjon egy privátot s elküldöm.
Ha megoldódik, akkor azt itt is jelzem majd.

Bagoly mondja verébnek, hogy nagy a feje, búsuljon a ló.

Dobd fel http://pastebin.com/ -re, es tedd be ide a linket.

while (!sleep) sheep++;

Nem a hosszával van a baj.
Csak nagyon csúf az az első ~20 sor és nem akartam magyarázkodásba kezdeni vele. Röviden annyi, hogy két sorban meg lehetne oldani azt vektorral, csak még nem tanultuk suliban, netről ellesni meg +1 hibalehetőség, megkérdezem hétfőn a tanárt (ezek érettségi feladatok és most kezdtem a tízet blabla kitérdekel), addig is megteszi ez a tömb, aminek rossz esetben is csak kevéssel van több eleme a szükségesnél.
Szóval ha működne a dolog, akkor kiírná a legtöbb egymás melletti egyforma számok számát a beolvasandó fájlból, aminek a tartalma:
32 45 56 34 34 34 34 55 11 11 11 11 11 11 12
plusz a részsorozatot, tehát:
6
11 11 11 11 11 11
Viszont nem ezt csinálja. Hol a hiba?

[ Szerkesztve ]

Bagoly mondja verébnek, hogy nagy a feje, búsuljon a ló.

Szia,

for(s=1; !read.eof(), s<=n; elozo=a)

A vessző helyett tegyél &&-t. Vesszővel a bal fele ugyan kiértékelődik, de nem számít bele a kilépési feltételbe. Az s pedig a te esetedben nem lesz nagyobb vagy egyenlő az n-nél, és így végtelen ciklusba kerül az egész.

Egyébként, ha csak annyi a feladat, hogy megkeresd a leghosszabb sorozatot, felesleges eltenned tömbbe. Elég egyszer végigmenni a fájlon, és menet közben megkeresni a legtöbb egymás után következő ugyanolyan számot.

OMG!
Minimum a fél programkód újraírására számítottam. Elásom magam
Köszi.
Az egy fokkal még bonyolultabb, vagy csak nem látom. Ez logic ez life. Működik s kész, igaz, hogy így s igaz, hogy nem jó felfogás, de legalább van hova fejlődni.

Bagoly mondja verébnek, hogy nagy a feje, búsuljon a ló.

Sziasztok!

segítségeteket szeretném kérni, hogy tudnám kiírni ezt a programot C-ben ?

Írjunk egy játékot.
csinálunk egy random generátort, kérjünk be egy számot! 1-100 ig
in= 98;

számítógép kiírja találgass:

beírtam: 15

A számítógép kiírja: annál nagyobb

110 beírok

A számítógép kiírja: annál kisebb

majd egy számnál kiírja hogy nyertél
win

Tudnatok ebben segìteni?

The easy day was yesterday!

Szívesen segítek! Meddig jutottál? Hol akadtál el?

"Nem gond ha nem vágod a párologtatók bináris nyelvét..."

Szia!

Megcsináltam a programot lefut, de nem teljes, mindjárt elküldöm

The easy day was yesterday!

rendben! várom a forrást!

"Nem gond ha nem vágod a párologtatók bináris nyelvét..."

átküldtem

The easy day was yesterday!

Most minek tanulsz?

The easy day was yesterday!

Ebben a videóban pontosan ezt a programot promolja sajátja ként a srác.
Mindenkinek ajánlom ezt a kis videót.
Vicces, de érthető és hasznos..
[link]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

"Viszont az algoritmus az algoritmus barmelyik altalanos celu nyelvben,"

+1

Ezt a mondatot, gondolkodást kellene megtanítani a mai programozótanoncoknak. Sokszor hallom hogy "C-ben simán megírom, de Java-ban ez bonyolult". Ehh.

Én HT-1080Z-n írta meg ezt a számkitaláló programot majd harminc évvel ezelőtt

"Nem gond ha nem vágod a párologtatók bináris nyelvét..."

A kettő nem üti egymást szerintem. Mondjuk én inkább olyat hallok, hogy Java-ban könnyebb.

Most egy kicsit elbizonytalanodtam. Ha pointert deklarálunk, akkor azzal helyet nem allokálunk csak egy memória területet, ahol a pointer lesz, ugye?

int *ptr;

ptr[0] = 0;
ptr[1] = 1;

Vagyis ez így helyes?

tely, baly, fojó, mennyél, mingyárt, telyföl, tolyás, malyd, kapú, egyenlőre, ejsd, jáccani, ahoz, fúj, hüje, muszály, alat, álok, lasan, fojtatás, ál, fontós, költsön, eggyüt, lyob (jobb?), mek, mongyak, milyért - !!! Tanúlyunk már meghejjessen irni... !!!