- Külföldi prepaid SIM-ek itthon
- Samsung Galaxy S25 - végre van kicsi!
- Megvan a Xiaomi 17 Max bemutatójának dátuma is
- Szívós, szép és kitartó az új OnePlus óra
- Samsung Galaxy S23 FE - nincsen sárkány
- Samsung Galaxy S26 Ultra - fontossági sorrend
- Xiaomi 17 - még mindig tart
- Honor Magic8 Pro - bevált recept kölcsönvett hozzávalókkal
- Hatalmas számokkal villog az új Xiaomi 17 Max is
- Honor 600 – kezes, kitartó, költséges
-
Mobilarena
Mobilarena
Új hozzászólás Aktív témák
-
Code Blocks-ra esett a választásom. Bele is kerültem az első akadályba, program begépelése után nem írja ki a megfelelő sort, szerintem el sem indul , mert a "Build log"-ban ezt írja:
""Rookie3 - Debug": The compiler's setup (GNU GCC Compiler) is invalid, so Code:
locks cannot find/run the compiler.
Probably the toolchain path within the compiler options is not setup correctly?! (Do you have a compiler installed?)
Goto "Settings->Compiler...->Global compiler settings->GNU GCC Compiler->Toolchain executables" and fix the compiler's setup.
Skipping...
Nothing to be done (all items are up-to-date).
"Kérdésem az lenne, hogy mi kell még ahhoz, hogy elinduljon? Köszönöm a választ.
-
Sziasztok!
Egy program részeként olyasmit szeretnék létrehozni, hogy elindul egy visszaszámláló ciklus, ami vagy akkor lép ki amikor lejár az idő, vagy akkor ha lenyomok egy bizonyos billentyűt. Viszont a program tárolja is el annak a lenyomott billentyűnek az értékét, így ahogy néztem a khbit() függvény kiesik.
Ez a kód jelenleg működik is (addig fut amíg le nem telik az idő, vagy nem nem nyomok egy billentyűt), csak a while után én meg is szeretném valahogyan vizsgálni a leütött karaktert.
scanf() / getch() / getchar() pedig azért esik ki, mert a következő karakterleütésig szünetelteti a program futását.#include <stdio.h>
#include <time.h>
#include <conio.h>
int main ()
{
time_t seconds;
time_t seconds2;
seconds = time(NULL)+3;
seconds2 = 0;
while (!kbhit() && seconds2!=seconds){
printf("töltelékszöveg, hogy lássam, hogy működik.\n");
seconds2=time(NULL);
}
return 0;
} -
Sziasztok!
Lenne pár kérdésem egy gyári függvénnyel, mivel nem vagyok egy programozó zseni.
1. while (WR) continue; kifejezésbe minek a continue? Szerintem tök felesleges, vagy mégsem?
2. #define EEPROM_READ(addr) ((EEADR=(addr)),(RD=1),EEDATA)
Ezt sem tudom értelmezni, hogy miért vesszővel és nem pontos vesszővel vannak elválasztva egymástól az utasítások.
Ráadásul ezt egy függvény return-nal meghívja: return EEPROM_READ(addr);
És elvileg az EEDATA-val kellene hogy visszatérjen, szóval miért nem egyszerűen return EEDATA?Valaki elmagyarázná ezt nekem?
-
Sziasztok!
Ezzel a kóddal kapcsolatban kérnék segítséget!
Az a része jól működik, hogy megmondja a program, hány megoldása van az egyenletnek, viszont csak 0.0000-kat ad vissza eredményül.
Gondolom a "double" - "int" részek kavarodnak, de már egy ideje görcsölök rajta és sehogy se jön össze. Valaki ki tudná javítani? Tanulnék belőle.
Ha nagyon nagy logikai hibák vannak a kódomban, akkor ne javítsátok ki, csak írjátok meg és megpróbálom összerakni máshogyan!!! -
sziasztok, adott az alabbi feladat:
Írjunk egy programot, amely a szöveg szavait adott hozzárendelési szabály szerint átalakítja:
pl. szöveg: “te lány, én meg fiúna mizu, mizu, mizu?”
a szabály: “te”->en “mizu”->mu
az atalakított szöveg: en lány, én meg fiú
na mu, mu, mu?
a kerdesem, az hogyan kellene az alabbi kodot valtoztassam, hogy mukodjon?
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
void main()
{
char string[255];
char uj[255];
char egy[2];
char ketto[2];
char c;
int db;
int i = 0;
int vege;
printf("kerem a szoveget\n");
gets(string);
vege = strlen(string);
uj =" ";
printf("%s", string[0]);
egy = "en";
ketto = "mu";
db = 0;
while (string[i] != '\0')
{
if ((string[i] == 't') && (string[i + 1] == 'e'))
{
strncat(uj, egy, 2);
db = 1;
}
if ((string[i] == 'm') && (string[i + 1] == 'i') && (string[i + 2] == 'z') && (string[i + 3] == 'u'))
{
strncat(uj, ketto, 2);
db = 1;
}
if (db = 0)
{
c = string[i];
strncat(uj, c, 1);
}
i++;
db = 0;
}
vege = strlen(uj);
strncopy(string, uj, vege);
printf("Az uj szoveg: %s", string);
getchar();
} -
Karma
félisten
Mi lehet a hiba? Miért nem tudok négy dimenziós tömböt deklarálni?
#include <stdio.h>
#include <stdlib.h>
int main()
{
int t[100][100][100][100], i, j, k, l;
int bentvan=1, tanar, tantargy, hetnapja, ora;
printf("Succesfull declaration\n");
for(i=0;i<100;i++){
for(j=0;j<100;j++){
for(k=0;k<100;k++){
for(l=0;l<100;l++){
t[i][j][k][l]=0;
}
}
}
}
do{
printf("Add meg a tanart");
scanf("%d", &tanar);
printf("Add meg a tantargyat");
scanf("%d", &tantargy);
printf("Add meg, hogy a het melyik napjan");
scanf("%d", &hetnapja);
printf("Add meg, hogy hanyadik ora");
scanf("%d", &ora);
if(tanar==0){
bentvan=0;
}else{
t[tanar][tantargy][hetnapja][ora]=1;
}
}while(bentvan);
return 0;
} -
Szia, köszönöm a válaszodat, ettől tartottam én is. Sebaj, nem lesz benne input, az úgyis csak extra lett volna.
Nem próbáltam, de szerintem ez működhet.
Stdinen semmi se biztos mondjuk.
Nyilván hülyeséget írtam, a getc alaphelyzetben blokkol, ha nem tud karaktert olvasni; ezt felülbírálni meg nem lehet platformfüggetlenül...
-
Munkáltató teszteken nem ilyen jellegű kérdések szoktak lenni, hanem írjon algoritmust és a fentebb írt szivatós kérdések.
(#4822) axioma: Ha jelentkezőt kellene tesztelni ahhoz lenne pár ötletem és akkor saját kútfőből, saját tapasztalatom alapján állítanám össze. A probléma, hogy most más állítja össze és én a másik oldalon ülök.
Például az enum-os kérdésem tapasztalatból jön. Adott volt egy enum tömb, amit használtunk 8- és 32 bites architektúrán is. A probléma ott kezdődöt, amikor memset-el 0-tól különböző értékkel próbáltuk inicializálni a tömböt.
MOD: eszembe jutott még egy. Ugye ezzel // egy sort lehet kikommentezni, vagy mégsem?
![;]](//cdn.rios.hu/dl/s/v1.gif)
Ezt a záró kérdésedet meg is válaszolhatnád, mert nem jön át, mire gondolsz
-
Header-guardnak hívják. Az ok, amiért létezik azaz, hogy egy forrásból akaratlanul is többször hívódhat ugyanaz a header fájl*, ekkor minden, ami az adott header fájl tartalmaz az többször fog szerepelni. Ennek a fordítók nem igazán szoktak örülni.
* például: source.c-nek szüksége van foo.h-ra és bar.h-ra, igen ám de a bar.h-nak is szüksége van a foo.h-ra
-
Sziasztok!
Nem vagyok programozó, nem is értek hozzá, de úgy alakult, nagy szükségem lenne egy programra, amit viszont csak forrásban adtak meg tt.
Linux alatt nem fordul le, kismillió hibát jelez, nem tudtam kibogózni. win7-en a mingw-vel próbáltam, de annak is mindenféle header állományok hiányoznak, pl. wait.h, ptrace.h, stb. Valaki tudna esetleg segíteni a fordításban? V. más valamivel próbáljam? Annak is örülnék, ha valaki simán csak lefordítaná win-es binárisra, abszolút távol állnak tőlem ezek a dolgok, viszont kéne a program
A közzétevőnek már írtam, de még nem jött válasz.
Előre is kössz a bármit! -
Sziasztok valaki tudna esetleg segíteni hogy ebben mi lehet a hiba mert nem tudok rájönni!!
#include<stdio.h>
typedef struct{
char nev[51];
double kapacitas;
}Pendrive;void beolvas(Pendrive *adat)
{
printf("Adja meg a nevet: ");
gets(adat->nev);
printf("Adja meg a kapacitast: ");
scanf("%f", adat->kapacitas);
}void nagyobb(Pendrive tomb[])
{
int i;for(i = 0; i < (strlen(tomb)-1); i++)
{
if(tomb.kapacitas > 2)printf("%s",tomb(i).nev);
printf("%i",tomb(i).kapacitas);
}}
int main(void)
{
Pendrive tomb[2];
int i;for(i = 0; i < 2; i++)
{beolvas(&tomb(i));
}
// nagyobb(tomb);
return 0;
}A hiba ott kezdődik, hogy nem használtad a Programkód gombot a forrás beszúrásakor, és így amellett, hogy nehezen olvasható, a [i]-kből mindenféle sima zárójel és dölt írás lett. Erre figyelj oda legközelebb.
Maga a kód rengeteg sebből vérzik, jelölöm amit ránézésre látok:
scanf("%f", &adat->kapacitas); -- mivel a double érték skalár, a scanf függvénynek a címét kell átadnod, ki kell rakni a & operátort hogy ne robbanjon.
for(i = 0; i < (strlen(tomb)-1); i++) ☠-- strlent nem szabad ilyen tömbre használni, csak és kizárólag nullterminált (azaz C) stringekre! A függvényedet úgy kéne módosítanod, hogy a darabszámot is átadd paraméterként.
printf("%i",tomb[i].kapacitas); -- ha egyszer double az érték, miért egészként akarod kiíratni?
De egyébként például a középsőt a fordító is mondja neked, hiszen lefordíthatatlan; miért nem nézed a hibákat?
Egy kicsit lemaradtam az írással
-
Lenne egy programom egy tömbben megadott számoknak kiírja a maximumát és a minimumát. A main függvény szinte teljesen adott volt. A minmaxot kellett megadni. A hiba az, hogy "too few arguments to function" az utolsó printf előtti sorban van ez a hiba, de pont annyi argumentum van amennyi kell szeirntem. Mi lehet a gond mit írjak át, hogy jó legyen? Itt a program #include<stdio.h>
void minmax( double tomb[10], double* mini , double* maxi) {
int i;
mini=&tomb[0];
maxi=&tomb[0];
for(i=1; i<10; i++){
if(tomb[i]>*maxi){
maxi=&tomb[i];
}
if(tomb[i]<*mini){
mini=&tomb[i];
}
}
}
int main(void) {
double t[] = {1.2, 2.3, 6.1, -3, -2.7, 2.7, 11.11, -20, 0.23, 4.1};
double min, max;
minmax(t, double* min, double* max);
printf("%lf\n%lf\n", min, max);
return 0;
} -
Szerintem:
for (i = 0; i < o; i++)
{
for (j = 0; j < s; j++)
{
if ((matrix[I][j] % 2) != 0)
{
printf("%d ",matrix(i)[j]);
}
}
}Végigmész a mátrix elemein balról-jobbra, fentről lefelé, és ha páratlan az elem, kiírod egy szóközzel. A kódban egyébként van egy komoly hiba: mi van, ha a felhasználó nagyobb számot ír be, mint a mátrix előre lefoglalt mérete?
-
Az a baj, hogy ha valaki ilyen fejlesztői környezeten akar tanulni vagy dolgozni akkor minimum tisztába kell lennie egy pár alap elektronikai kérdéssel amelyek alapot adnak a további kiegészítésekhez melyek aztán szerepet játszanak majd a bonyolultabb fejlesztésekben.
buherton, itt is szépen leírta milyen egyéb alkatrészeket lehet beépíteni a tanuló nyákra, de én javaslom az elsőt úgy megépíteni, hogy a szükséges élesztésen kívül csak a felhasználható I/O lábak legyen kihozva tüskesorra.
Aztán későbbiekben bármit rá lehet aggatni könnyedén.De nem egyszerűbb, ha az emberfia először lát egy ilyen rendszert működésben, amin a beágyazott programozás alapjait illetve egyszerűbb elektronikai illesztéseket gyakorolhatja? Aztán ha elég stabilnak érzi a talajt, lemásolja a kapcsolási rajzát vagy saját kútfőből épít sajátot?
dabadab egyébként jól megfogta az egyik gondolatom lényegét
Pont arra gondoltam. A szoftveres "luxus" hiánya (OS, driverek, stb.) szerintem gyorsan megugorható, fel se merült bennem, hogy valaki úgy akarna uC-t programozni. -
Az uC-re úgy kell tekinteni, mint egy mezei digitális áramkörre kapcsolás tervezésnél. Ha speciális interfészeit akarod használni, akkor az adatlapban megtalálsz mindent. A legnehezebb a próba panel esetén, hogy mi kerüljön rá? Aztán a tervezés már nem probléma. Amit ajánlani szoktam az a 2-3 kapcsoló, 2-3 nyomógomb (természetesen Schmitt triggerelve), LCD kijelző, 2 7 szegmenses (ezt én shift regiszterrel szoktam meghajtani, amit aztán SPI-al hajtok meg), 8 LED, RS-232, I2C-s EEPROM, SPI-s hőmérséklet érzékelő, Egy LED az egyik PWM kimenetre, a másik PWM-re pedig egy Darlington-ba kötött transzisztor pár, 32 kHz-es kvarc az RTC-nek, egy poti az egyik ADC-re. Ha tud az uC USB-t, akkor értelemszerűen azt is kivezetm. Ahogy a kolléga mondta, minden uC lábat tüskesorozni kell. Ahogy látod ezenek a nagy része sima GPIO lábra kerül, csak az EEPROM, SPI és a soros port a speciális, mert azok kommunikációs lábakra kerülnek.
Tessék olvasgatni az adatlapokat.
-
Magamból kiindulva azt tanácsolom, hogy ne használj semmilyen előre legyártott kittet.
Kezdésnek szerezz minimum annyi tapasztalatot, hogy saját magadnak megépíts egy olyan gyakorló nyákot amelyen a Mikrochip minden használható lábát kivezetsz tüske sorra.
Természetesen úgy kell megépíteni, hogy az azonnal éleszthető legyen tehát az egyéb áramköröket és programozói felületet integrálnod kell az elején.
Én mint kezdő ezt tanácsolom, nagy segítség a tanulásban illetve a fejlesztéseknél és már megismerkedsz a PORT-okkal
Csak, hogy ajánljak is valamit ami olcsó és jó az a PIC...
Ingyenes nyáktervező: Sprint Layout
-
Szia!
Az első és legfontosabb dolog az angol nyelvtudás. A nélkül csak a magyar fórumokra és cikkekre hagyatkozhatsz, ami nem túl sok.
El kell döntened, hogy hobbi célból vagy komolyabban szeretnél-e ezzel foglalkozni.
Ha komolyan akarsz ezzel foglakozni, akkor csak is az ARM jöhet szóba. Ezt csak ajánlani tudom, mert amit megírsz az menni is fog. Ezen kívül még annyi költség merül fel, hogy a perifériákat megvedd. A NYÁK-on minden elő van készítve, így ha pl. Ethernetet akarsz rákötni, akkor csak a csatlakozó kell. Az USB dettó. Van rajta minden ami kellhet. Sőt a debuggerrel bármilyen NXP ARM-t programozhatsz! Van hozzá gcc fordító fork, és egy Eclipse CDT IDE fork. Mind a kettő ingyenes.
Ha hobbi szinten szeretnél foglakozni, akkor három gyártó jöhet szóba. A Parallax, Atmel, és a Microchip. A Parallax-nak azaz érdekessége, hogy 8 mag van benne. Egyáltalán nem bonyolult, de sajnos saját nyelve van, illetve kevésbé ismert. Az Atmel és a Microchip nagyjából egyszinten van. Van amiben egy jobb, van amiben a másik. A hobbielektronikán elég sok hsz-n keresztül ment a flame war, hogy melyik a jobb.
Az Atmel-t választottam, mert nem vagyok fordítóhoz, és fejlesztő környezethez kötve. Ugyanis az AVR-nek ugyanúgy van gcc forkja, és azt bármilyen univerzális fejlesztő környezetben használni. LUFA project néven készült egy AVR ISP mkii klón, ami szinte teljesértékű a gyári programozóval. Továbbá az Atmel biztosította, hogy otthon is utána építhető lehessen az AVR JTAG, amivel már debuggolni is lehet a cuccot. A Microchip pozitívuma, hogy bárhol beszerezhető, és a PICkit 2 elég sok mident tud debuggolni. Ami viszont nem tetszik, hogy a fordítóval nincsenek jó emlékeim, és még gcc fork sincs belőle (nem véletlenül?), az IDE viszont nem rossz, de szinte esélyed sincs másikat használni annyira egybe integrálták az egészet. Ez is a PIC-el a legnagyobb problémám, hogy teljesen zárt. Nincs semmilyen szabadságod.
Bármi is legyen a döntésed a használt program nyelv a C legyen. Van Basic meg Arduino, meg mit tudom én mi, de az igazi beágyazott rendszer fejlesztő C-ben dolgozik, és ha a jövőben ebben szeretnél dolgozni, akkor ebben kell majd.
MOD: Az AVR-nél mindent meg lehet otthon építeni, de szerintem ugyanez vonatkzoik a Microchipre is. Ha drágállod a gyári megoldásokat, akkor érdemes az eBay-en körül nézni a klónok után
.MOD2: Minden gyártó ad ki egy adatlapot a termékéhez. Abban minden fontosabb infót megtalálsz. Természetesen angolul íródtak. Rengeteg példa kód elérhető a neten.
-
Bocsi ha terhelem ezt a topikot, de itt írogattatok ezzel kapcsolatban, meg nem tudom hogy itt PH-n belül hol kérdezhetném meg még ezt máshol. Szóval:
Nyáron ha lesz egy kis időm szeretnék elkezdni kicsit foglalkozni a mikrokontrollerekkel, és ehhez szeretnék egy kis segítséget kérni. Hol tudok ilyen cuccokat vásárolni/rendelni, hol tudok valami tényleg hasznos anyagot hozzá olvasni, vagy ha videó akkor nézni.
Programozási ismereteim vannak már C-ben és C++-ban is, de így gyakorlatban még nem raktam össze semmi hasonló cuccot.
Előre is köszi! -
A probléma egy kicsit összetettebb, mert az avr-gcc, ezt tudja:
static FILE mystdout = FDEV_SETUP_STREAM(usart_putchar_printf, NULL, _FDEV_SETUP_WRITE);
int main( void )
{
stdout = &mystdout;
printf("Hello world");
}
void usart_putchar_printf(char data, FILE *stream)
{
bájt küldése soros porton
}és ezt szerettem volna elérni a PC-n is, hogy végül egy függvényt hívjon minden karakter kiíráskor.
-
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.
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. -
Srácok...
Van egy ilyen tömböm:
unsigned char listabuffer[15][18];
Sajnos fordításnál ki írja a program, hogy a "verem keret túl nagy".A program lényege, hogy a memóriából a 15db előre elmentett nevet kiolvasom amelyek külön-külön 17karakteres +1 a lezáró.
Ötletet kérnék, hogy még is, hogy váltsam ki a többdimenziós tömb használatát?
A gond az, hogy az összes nevet meg kell jelenítsem, hogy választani lehessen belőle.
Illetve van egy mód amire gondolok, de annak kivitelezését kerülném, ha van hatékonyabb megoldás.
(Az én ötletem az, hogy mivel az LCD kijelző maximum 4sort tud egyszerre mutatni így négyesével olvasnám be és léptetném.)
Ötletek?
Előre is köszi.. -
Nem büdös, csak nem tudom bele tenni.
Ha beleteszem akkor iszonyat mennyiségű globális változót kellene használnom vagy túlbonyolítani a programot a függvényesítés miatt.
Minden program rész összefügg és folyamatos kapcsolatban kell lenniük a memória kezelése miatt.
Így is van vagy 20db külön függvény már és még lesz legalább ennyi...A switch utasítás meg ugyan az lenne mint az if csak itt nem else if lenne leírva soronként hanem a case: .
-
Összedobtam egy kis részletet miről is van szó és ami jóbban szemlélteti a dilemmámat.
goto vagy else if megoldással:main(){
menu:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Meghívhatja saját magán kívül mindegyiket
pofil_betoltve:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Meghívhatja a menu-t és a start-ot
uj_profil:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Meghívhatja a menu-t és a pofil_betoltve-t
prifil_szerkesztes:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Csak a menu-t hívhatja meg
profil_lista:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Meghívhatja a pofil_betoltve-t és a menu-t
start:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Egyéb más funkciót fog tudni meghívni és visszatérésként a pofil_betoltve-t
}
main(){
unsigned char navigacio; //Függően attól hogy a felette lévő feltételek miként értékelődnek ki a szerint töltődik fel értékkel
while(1){ //végtelen ciklusban pörög és folyamatosan vizsgálnia a kell a feltételeket
if(navigacio==0){
//hasonlóan mint feljebb
//szükséges változók nullázása
//Sok sor program kód
//navigacio-s változót írjuk felül attól függően melyik feltételbe akarunk navigálni
}else if(navigacio==1){
//-- " --
}else if(navigacio==2){
//-- " --
}else if(navigacio==3){
//-- " --
}else if(navigacio==4){
//-- " --
}else if(navigacio==5){
//-- " --
} //-- " --
}
}Így talán átláthatóbb és érthetőbb a kérdésem.
Ki melyiket használná?
GOTO vagy ELSE IF? -
"Nem ertem mit akarsz osszevonni, megmondom oszinten... lesz x byte teruleted, arra rateszel egy olyan strukturat, amilyen illik az adatokra. Lesz benne char[] es lesz benne unsigned byte meg unsigned short."
Csak kérdeztem, hogy megoldható e, hogy egyszerre 2 típust tároljak egy változóba, de ez nem megoldható.
Így marad egy külön char ami 8bites és egy short int ami 16bites.
Hozzáteszem, hogy csak egy adat az alsó fűtés igényel 1bájtnál nagyobb területet.
Ezt túl is tárgyaltuk...En me'g azt nem ertem, hogy ha rogton az elejen hogy lehet 2 VAGY 3 byte/char... feltoltod ugy hogy (karakteresen) #12 akkor honnan fogod tudni, hogy igy kell olvasni, es a 2 nem az utana kovetkezo adathoz tartozik es a #1-rol van szo?
Itt a "#" kettős kereszt lesz egy speciális karakter amely jelzi az érvényes adatblokk kezdetét. (ez 1bájt)
Az utána következő 1bájtban egy szám lesz ami 0-14 közt van mivel maximum 15db különálló profilt lehet majd előre rögzíteni a memóriába.
A program elején egy feltétel vizsgálattal ellenőrzöm és beazonosítom az utolsó betöltött profilt.
Az azonosítás több részből áll, de ez már más téma... -
Fiúk, Lányok!
Lenne egy valószínűleg vicces kérdésem, de muszáj megkérdeznem mert nem vagyok biztos a gondolat menetemben.
A lényeg, hogy van 2 típus, char és int.
El akarom menteni memóriába és az a kérdésem, hogy ha számokat akarok elmenteni char típusként akkor 1 szám 1bájtot fog foglalni?
Tehát ha egy 8-as számot akarok char típusként elmenteni akkor az 1bájtot fog foglalni a memóriában?
És ha 12-őt akkor az már 2bájtot igaz?
Viszont int típusként 0-255-ig 1bájt igaz?
Vagy char típusként is megmarad a 0-255-ig az 1bájt?Én úgy gondolom, hogy char típusnál 1 szám vagy betű 1bájtot foglal.
Okosítsatok fel.
Előre is köszi.. -
Közben rájöttem
Kicsit agyalnom kellett az eddig tanultakon bár annak nem örülök, hogy lépésenként kell végignézni a karaktereket ...unsigned int i=0;
unsigned char teszt[4] = {'1','A','3','\0'};
for(i=0; i<=sizeof(teszt)-1; i++){
if ( (teszt[i] >= 'A' && teszt[i] <= 'Z') )
printf("Ez egy betű!\n");
else
printf("Ez egy számjegy!\n");
}Közben látom, hogy megelőztetek
Köszi..Szerk:
Értem akkor inkább a számokat vizsgáljam, mert az rövidebb ideig tart.
Világos.. Mindig tanulok valami újat.
Néztétek a videót amit linkeltem ezzel kapcsolatban?
Kukk meg itt: [link] -
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...
Az atoi semmiképp se jó választás, hiszen ha nem számjegy karakterrel találkozik, azt simán kihagyja. A "11A" stringedre ha jól saccolom, a visszatérési érték 11.
Az elemenkénti végignézést javasolnám személy szerint, az nem túl költséges, és biztos jó eredményt ad. Mondjuk az a-zA-Z vizsgálat helyett sokkal egyszerűbb azt nézni, hogy az i-edik karakter >= '0' és <= '9'
Na meg nyilván ha == 0, akkor le kell állni a ciklussal.
alapz@j: Ha a memset ezt az intrinsic megoldást használná, nem lenne az egész optimalizáció vs. biztonság mizéria
-
-
Ha nincs ellenvetes, akkor a DevC++-t lecserelem QtCreatorre.
Meg igy jobban megnezve, a Turbo C is lehet, hogy aktualitasat vesztette. Ahelyett mondjuk VS Express?Mindenképpen jobb lenne a QT Creator és a VS Express
. Illetve néhány oldallal ezelőtt volt az a másik windowsos IDE, az is megérhet egy említést. -
#include <stdio.h>
main()
{
int c;
int gyak[ 256 ] = { 0 }; /* az egész tömböt nullázza */
while ( ( c = getchar() ) != '@' )
++gyak[ c ];
for ( c = 0; c < 256; ++c )
if ( gyak[ c ] )
printf( "%c: %d\n", c, gyak[ c ] );
}Írjunk programot, amely a billentyűzetről látható karaktereket olvas mindaddig, amíg a @ karaktert meg nem kapja! A program határozza meg és írja képernyőre a beolvasott különböző karaktereket és azok gyakoriságát!
Ez egy megoldott feladat volt. Kérdésem lenne, hogy jól értem-e amit csinál.
míg a beütött karakter nem egyenlő @-val, addig folyamatosan tölti fel a tömböt, majd a for ciklus számolja a leütött karakterek számát és hogy melyikből mennyi van?(ezt itt nem teljesen vágom, hogyan számolja)
majd az if szerkezet kiírja?
-
Bar a butasag jelzot nem tartom erre szerencsesnek, de maradjunk abban, hogy ezek szerint vannak munkahelyek, ahol ezt a trukkozos stilust az en eddigi tapasztalataim ellenere szeretik.
Azt megkerdezhetem, hogy milyen celu program az, amin a "szepseg" helyett kevesebb programkod = jobb karbantarthatosag elv menten csinaltatok atirast? Meg esetleg hogy hany fo fejleszto meretu az a kod, az is erdekes lehetne. -
Tömb kezeléssel kapcsolatos:
Közben sikerült eljutnom odáig, hogy elolvassam a linkelt írásodat.
Most úgy oldottam meg segítséggel a dolgot, hogy egy függvénynek átadom a kellő paramétereket (float) és a feldolgozás (string-é alakítás) végén feltölt egy tomb-öt (amit a program elején "volatile unsigned char szamok[10]" változóként deklarálok) az eredménnyel.
Aztán ahol kell ott pedig kiíratom string-ként printf() %s megadásával.Az írásodban viszont arra hívod fel a figyelmet, hogy ne használjuk ezen megoldást.
Vagy nem jó értelmeztem? (globális változók)
Jó az elmélet vagy a globális változó miatt ez gondot okozhat nekem? -
Ezen elven kezdtem el agyalni:
void float_to_str(float szam){
int number, mennyi = 0, i = 0, tizedes = 0, oszto_tomb[8];
if(szam < 10)
tizedes = 1;
else if(szam < 100)
tizedes = 2;
else if(szam < 1000)
tizedes = 3;
else if(szam < 10000)
tizedes = 4;
else
printf("Ez a szám már túl nagy.");
number = szam * 100000;
while(number != 0) {
oszto_tomb[i] = number % 10;
printf("%i, ", oszto_tomb[i]);
number = number / 10;
mennyi = i;
i++;
}
printf("\n");
for(i = mennyi; i >= 0; i--){
if(i == (mennyi+1)-tizedes)
printf("%i.", oszto_tomb[i]);
printf("%i", oszto_tomb[i]);
}
printf("\nHány karakter: %i\n", mennyi+1);
}
//kiíratása a main függvényen belül
float_to_str(12.34567);Ez nádjából jól működik amíg 10-nél nem kisebb a lebegőpontos szám amit beadok neki.
Így néz ki egy kimenet:
7, 6, 5, 4, 3, 2, 1,
12.234567
Hány karakter: 7
12.234567 (mondjuk valamiért itt 2db 2-es látszik pedig csak 1 van a sorozatban)
A lényeg látszik belőle, hogy mit is szeretnék.
Ez hogy lehet hatékonyabban megoldani? -
sprintf-nél még nem járok.
Még csak a változó típusokat, függvényeket, ciklusokat és a tömböket olvastam végig.
Van még bőven mit olvasnom
550oldalas a könyv és még csak a 160. oldalnál járok, de szeretem a leírtakat gyakorlatban is kipróbálni és szeretném azok működését magam is megírni és megérteni.
Az nem kivitelezhető egyerűen, hogy megfordítás nélkül szétválasszuk a bevitt értéket? (egész számot)
Pl: 123456 = 1,2,3,4,5,6
Mindenképp a helyes út a vissza osztás és a maradék eltárolása és ezen folyamat újra és újra forgatása míg nem teljesen meg nem kapjuk egyesével a számokat? -
-
Hmm, a JIT kód nem tűnik túl okosnak, nem tudom mitől gyors:
0x00007fe2237a679a: movsd 0x10(%rbx,%rbp,8),%xmm0 ;*daload
; - Test::summUp@12 (line 11)
0x00007fe2237a67a0: movsd 0x8(%rsp),%xmm1
0x00007fe2237a67a6: addsd %xmm0,%xmm1
0x00007fe2237a67aa: inc %ebp
0x00007fe2237a67ac: ucomisd 0x20c(%rip),%xmm0 # 0x00007fe2237a69c0
; {section_word}
0x00007fe2237a67b4: movsd 0x8(%rsp),%xmm0
0x00007fe2237a67ba: ja 0x00007fe2237a67c0
0x00007fe2237a67bc: movapd %xmm0,%xmm1 ;*iinc
; - Test::summUp@26 (line 10)
0x00007fe2237a67c0: cmp %r11d,%ebp
0x00007fe2237a67c3: jge 0x00007fe2237a67cd
0x00007fe2237a67c5: movsd %xmm1,0x8(%rsp)
0x00007fe2237a67cb: jmp 0x00007fe2237a679aNem fordítja újra, vagy valami más sunyiság? Nem értek az SSE-hez (x86 assemblyvel is 286-os szinten ragadtam), de ránézésre lényegében ugyanaz, mint a C eredménye.
-
Srácok OSX alatt szeretnék C-ben programozni illetve tanulni a nyelvet.
Tudnátok ajánlani fejlesztői környezetet amit könnyű használni és fordít is?
Drag en Drop fejlesztők nem érdekelnek.
Xcode és a Code Wariors-t nézegetem, de nem tudom melyik verziót érdemes beszereznem belőlük.
Kérném segítségeteket, hogy jól válasszak.
Stephen G. Kochan könyvéből szeretnék lépésről lépésre tanulni és a feladatokat elvégezni.
Köszi előre is. -
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 legtöbb nyelv platformfüggetlen. A tényleges munkavégzéshez bevonzott frameworkök meg nem (merthát lehet több féléven át helloworldözni STL-el, de a valóságban azért hálózat, adatbázis, IPC, meg ki tudja mi jön szembe). És máris nem olyan fontos szempont.
Meg ugye a Linux desktop kit érdekel
</troll>A Vuze mindig Java-alapú volt szerintem, még Azureus korában is. Az OpenOffice meg főleg natív, Java kiegészítésekkel.
-
Valami rémlik ezzel a lépkedős debuggal kapcsolatban, órán is csináltuk már párszor. fel lehet venni debug közben egyes változókat is külön, hogy ellenőrizzük mi van benne, stb.
Az a gond a másik fejlesztő környezettel, hogy vizsgán is VS-t kell használni, valamint ezzel is javítanak. VS nem GCC-t használ hanem valami jóval "kötekedősebb" compilert... Én eddig CodeBlocks-ban tanultam/programoztam, ami nekem sokkal jobban tetszett, de hát muszáj VS-t használni...
Egyébként, majd androiddal szeretnék foglalkozni, bár egyik ismerősöm aki várja a C-t, java-t, stb. azt mondta, hogy nem egy túlzottan átlátható nyelv... és ha nekem már/még a C-vel is gondjaim vannak akkor nemtom, hogy fog menni... Persze remélem megfogom majd rendesen érteni az egész program írási "létformát", sajnos 1 félév után még szinte teljesen tudtatlan vagyok (mint ahogy az látszik is
)(#4403) Karma: Megfogom majd nézni akkor azt a ..._s verziót
-
közben nekem is beugrott, hogy a 4 hossz nem lesz jó, köszi így már nekem is jó
Ez az IDE debugger azmiaz? Én VS2010-et használok. Valamint, azt tudjátok, hogy miért nyávok a fordító az strcat-ra és ajánl helyette strcat_s-t?
Az strcat_s azért jó, mert odafigyel arra, hogy a célterületből véletlenül se szaladjon ki. Ha egy négy hosszú blokkba beleírnád azt, hogy "MCCXXXIV", akkor az strcat kifut és felrobban, a safe változat beírja hogy "MCC" és csöndben megy tovább.
A debuggert használod most is, csak tud sok hasznos dolgot még
Például a programsoraid mellett bal oldalt kattintasz, breakpointot raksz be, aminél a program megáll és lépésenként követheted a menetét.buherton: Tényleg előfordulhatnak felesleges warningok, de ez egyáltalán nem az! Konkrétan elkerülhető lett volna a crash. Az strcat_s tényleg nem szabványos, de az strncat igen, ami szintén egy biztonságos alternatíva más platformon.
Meg úgy egyébként a warningok azért vannak, mert valamit rosszul csinál az ember. Tanulásnál különösen fontos megérteni hogy mit...
-
-átírva calloc-ra
- említett else-es gondok (elvileg) megoldva
= cmd továbbra is lefagyu.i.: Nem kéne a romai tömb-be az átalakított sztring után 1 lezáró nulla? Nekem azt mondták, ha az nincs a szting végén akkor szar a char tömb? (vagy ezt is orvosolja a calloc a kinullázott bitekkel?)
Túl kevés memóriát foglalsz, ezért robban fel. n = 4, de az eredmény bőven hosszabb ennél
Ha azt nézzük, hogy egy számjegy római alakja maximum 4 karakter lehet, a 4*n+1 byte biztosan elég lesz. Arra átírtam a callocot, és ki is írta az eredményt hiba nélkül.
Egyébként megéri IDE-vel debuggolni a programot. Egyrészt menet közben látod hogy melyik változód milyen értéket vesz fel, másrészt egy kicsit több infód lesz az összeomlásról is, nem csak hogy "kifagy".
-
és
-Bele raktam a main-t is, hogy lássátok, hogyan akarom meghívni, valamint felszabadítani a fv-t (fv deklarációt most nem raktam bele..)
-az a (romai[0]=0) nem értem, hogy miért kell (?), ha string van benne, akkor miért legyen benne 0 az elején?
-megcsináltam a 0-ás karakterek gondját ha minde igaz.2) Mert amikor a malloc lefoglalja a területet, az még korábbi szeméttel van tele. Bármi lehet ott, beleértve a Shakespeare összest
Azért kell a 0, hogy biztosan üres string legyen belőle.Alternatívái a memset függvény (az egész területet egységesen nullázhatod vele, illetve a malloc helyett calloc fv. kapásból tiszta területet ad.
-
A gond az, hogy dinamikus tömböket még nem tanultunk, mutatókat is még csak fogjuk. Azt a stackelős részt szintén nem értem :S Valamint, az miért jó ha bemenő paraméterként adom meg a char tömböt? egy részről, ha arab szám a bemenet akkor mért char? Másrészt meg a .csv fájlból való input, fv kérés és benne az érték is int lesz. (gondolom én)
-
A gond az, hogy dinamikus tömböket még nem tanultunk, mutatókat is még csak fogjuk. Azt a stackelős részt szintén nem értem :S Valamint, az miért jó ha bemenő paraméterként adom meg a char tömböt? egy részről, ha arab szám a bemenet akkor mért char? Másrészt meg a .csv fájlból való input, fv kérés és benne az érték is int lesz. (gondolom én)
-
Sziasztok!
1 beadandót készítek ahol tömören annyi a lényeg, hogy excel-ből kiimportálunk 1 .csv fált, amit be kell olvastatni a programba és a megadott excell fv-et kell megvalósítani és meghívni c-ben. Többek közt egy arab-római alakító fv-t. Én ehhez szeretnék egy kis segítséget kérni, nagyjából már kész van, de vannak benne hibák, viszont nem találom, hogy mi. Pl. a vissatérési érték megadása nem hinném, hogy jó lenne. Mert jelenleg pl a return romai[20]; van megadva de ez (tudomásom szerint) csak a tömb 21. elemét adná vissza, de próbáltam már "romai[]" vagy "romai" verzióval is egyik se volt jó, el se tudtam ezekkel indítani a programot. A jelenlegi ...[20]-as verzióval meg lefagy a cmd futtatás után egyből. Tudnátok segíteni a finomhangolásban?
-
Koszi a valaszokat. Igen, a program a byte-ok bizergalasan kivul semmi kulonoset nem csinal (egy titkositast kell ratolni ill. leszedni a bytetombre mint uzenetre), amugy luminary.
Jo, akkor Qemu... azert gondoltam hogy tulzas, mert a manualjanak 90%-a a periferiak, a net, a kulonbozo mas eszkozok beallitasa, ami nekem mind nem kell. Elkezdtem a leiras szerint a ceges win7 64 bitesre felepiteni, de vagy rosszat toltottem le, vagy a korabban felpakolt mingw nem jo vagy nemtudom, a zlib helyrerakas es a .configure elnagyolt modositasi leirasa kornyeken adtam fel (a letoltott qemu-ban levo qemu-doc.html volt amit probaltam kovetni, lehet hoyg valami masik leirast kellett volna keresnem).
Vegulis linux is van keznel ha nagyon akarom (otthon legalabbis, bar egy oskovulet gepen es nem is a legfrissebb verzio), lehet hogy akkor majd azzal nekiallok, hatha egyszerubb (meg tudtak csinalni automatizaltabbra), mint windows alatt a sok szuttyoges.Most nézem, hogy a leírásom elavult, a benne lévő Debian letöltési linkek már nem aktuálisak. Így az kuka.
Viszont cserébe találtam aktuális image-eket, leírással, menetkészen
Még telepíteni se kell. -
Koszi a valaszokat. Igen, a program a byte-ok bizergalasan kivul semmi kulonoset nem csinal (egy titkositast kell ratolni ill. leszedni a bytetombre mint uzenetre), amugy luminary.
Jo, akkor Qemu... azert gondoltam hogy tulzas, mert a manualjanak 90%-a a periferiak, a net, a kulonbozo mas eszkozok beallitasa, ami nekem mind nem kell. Elkezdtem a leiras szerint a ceges win7 64 bitesre felepiteni, de vagy rosszat toltottem le, vagy a korabban felpakolt mingw nem jo vagy nemtudom, a zlib helyrerakas es a .configure elnagyolt modositasi leirasa kornyeken adtam fel (a letoltott qemu-ban levo qemu-doc.html volt amit probaltam kovetni, lehet hoyg valami masik leirast kellett volna keresnem).
Vegulis linux is van keznel ha nagyon akarom (otthon legalabbis, bar egy oskovulet gepen es nem is a legfrissebb verzio), lehet hogy akkor majd azzal nekiallok, hatha egyszerubb (meg tudtak csinalni automatizaltabbra), mint windows alatt a sok szuttyoges. -
Na igen, a qemunál karcsúbban elég nehéz megúszni
Axioma, az hogy big endian valami, még nem sok mindent definiál szerintem. Kérdés az architektúra (ARM, MIPS, SuperH, MicroBlaze, stb.), meg a szoftverkörnyezet is (Linux, valamilyen RTOS, nyers kód a vason). Csak mert ettől is függ, hogy mit kéne emulálni vagy szimulálni.
Szerk.: na jó, második nekifutásra mégse olyan fontos kérdések, mert maga a program elmondásod szerint elég minimalista. Ettől függetlenül nem nagyon lehet megúszni a QEMU-t és a Limux telepítést, csak hogy legyen min futtatni.
Itt egy MIPS útmutató, és itt ugyanez SPARC-kal. Valamelyiket lenyomod, és kész is leszel
-
Ha egy 64 bites változóban szeretném átírni a biteket az 5. bittől kezdődően 7 bit hosszan akkor hogy kellene kimaszkolni, hogy a többi bit ne változzon? Nem jut eszembe semmi értelmes általános megoldás. AZ offszet és a hossz változhat.
Köszi
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
-
É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?
-
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.
-
Kiegészítés (#4195) dabadab hsz-re.
1. feleslegesek a typecast-ok és a jövőben kerüld ezeket, mert könnyen kerülhetsz olyan helyzetbe, amikor jön a fej vakarás, mert nem fut a kód, mint például:
void foo(long *bar)
{
*bar = 23424234;
}
int main(void)
{
char bar;
foo(&bar);
return 0;
}2. formázás: ez az adott sor végére rakni a { nem C-szerű formázás, hanem tán a Java-ból jön, és ajánlott ott használni. Továbbá próbáld kialakítani a saját stílusod, és tartsd magad ahhoz, mert könnyebb neked és másnak is olvasni a kódod.
int* foo; helyett int *foo; mert ebből is lehetnek gondok, mint int* foo, bar; és két pointer helyett lesz egy pointer és egy változó, és nincs olyan típus, hogy int pointer, hanem int-re mutató pointer van csak.
3. óvatosan az ilyenekkel:
for(i=0;i<n;i++)
if (palyak[i]==0)
{
nemsi_index[a]=i;
a++;
}Ugyanis nem feltétlenül portable a kód. Sajnos nem mindegyik fogadja el így ezt a formát. Az ilyen formával már kevésbé lehet gond:
for(...)
{
if(...)
...;
...;
}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.
-
Bontsuk kette a problemat.
Mint rajottem, az ftell/fgetpos csak akkor mukodik "helyesen", ha mar olvastam a streambol.
Ha elso olvasas elott adom ki, akkor -20-at ad vissza, es innentol fogja egyesevel novelni/csokkenteni a poziciot minden getc/ungetc utan, nem nullatol.
Ez a kisebbik problema.Nagyobbik bajom az, hogy a getc platform fuggoen kezeli a sorvege karaktereket.
Pl. Visual C++ 2010 Win alatt ha \n karaktert lat, akkor lenyeli az utana jovo \r karaktert es mindig kettovel noveli a fajl poziciot.
Ez azert problema, mert a feldolgozando forraskodok egy resze UNIX alatt lett mentve, ott meg nincsen \r az \n utan, de akkor is kettovel noveli a poziciot...Plusz nehezitesnek vannak olyan forraskodok is, amiben nincs \n, hanem \r-rel vannak tordelve.
Probaltam szamolni, hany getc/ungetc-nel jarunk, de az sem ad pontos eredmenyt, mivel nem tudom eldonteni, hogy a latott \n karakternel eggyel vagy kettovel noveljem az indexet.
Windows alatt automatikusan utana rakott \r egyaltalan nem jon at a getc-vel, nem tudom megszamolni.Bináris módban elvileg nem foglalkozik a sorvégekkel, bár nem tudom ezt a morzsát tudod-e használni valamire
-
Szittja: a kill függvénnyel vagy az azonos nevű közismert segédprogrammal.
krisztianAMG: azért mert a scanf_s csak úgy szereti a string beolvasást ha a hosszt is megadod, pl. így: scanf_s("%s", 99, string); Ezt egyébként az msdn szépen le is írja, tessék máskor ott olvasgatni.
Bobrooney: javaslom nézz utána a scanf-nek és a pointer-tömb ekvivalenciának.
-
Karma
félisten
Sziasztok! Osztott memóriás feladatban kérnék segítséget:
Olyan programokra van szükség, ami létrehoz egy osztott memória szegmenst; az egyik program beleír, és vár néhány másodpercet, bináris szemafor segítségével védi az írást; a másik program pedig kiolvas belőle.Az shm szegmens létrehozása megvan, de a többit nem tudom hogyan..
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define SHMKEY 69906L
int main()
{
int shmid; /* osztott memoria azonosito */
key_t key; /* kulcs az osztott memoriahoz */
int size=512; /* osztott mem szegmens merete byte-ban */
int shmflg; /* flag a jellemzokhoz */
key = SHMKEY;
/* Megnezzuk, van-e mar SHMKEY kulcsu es size meretu szegmens. */
shmflg = 0;
if ((shmid=shmget(key, size, shmflg)) < 0) {
printf("Nincs meg szegmens! Allitsuk elo!\n");
shmflg = 00666 | IPC_CREAT;
if ((shmid=shmget(key, size, shmflg)) < 0) {
perror("Az shmget() system-call sikertelen!\n");
exit(-1);
}
} else printf("Mar van ilyen shm szegmens!\n");
//printf("\nAz shm szegmens azonositoja %d: \n", shmid);
exit(0);
} -
Ha a linker szerint az ex_task4.o-ban is benne van, az azt jelenti, hogy huncutság van, például az ex_task4.c-ben lehet egy #include "ex_init4.c".
Ezt nem tudom, hogy honnan tudtad, de tényleg így van. Az ex_task4.c-ben semmilyen __heap_start-os declarálás, definiálás vagy hasonló sincs. De ez miért jelent problémát?
MOD: Arra gondolsz, hogy a make környezet úgy fordítja, hogy minden c fájt fordít, és ennek az lesz a következménye, hogy az ex_task4.c-ből includálva van az ex_init4.c ezért gyakorlatilag az ex_init4.c kétszer van fordítva? És amikor a linkeléshez ér, akkor jön a felismerés, hogy két __heap_start van, mert bár az ex_task4.c nem tartalmazza, de az include miatt mégis bele kerül.
(#4093) Karma: Igen, több példa is van, viszont úgy van megcsinálva, hogy a közös dolgok 4 init fájlban vannak, és a különböző példák ezeket include-álják és így egy rakat fölös kódot nem kell ismételten leírni. Ilyen a main, a task inicializálás, deklarálások, stb..-k. Nem túl szép, de az biztos hogy hatékony, de egyelőre még nem fordul...
-
Kezd nagyon felidegesíteni az Eclipse. A fordítás rendben lemegy. A problémák a linkelésnél jönnek elő. Hogyan lehet az olyan problémákat kiküszöbölni mint pl:
./ex_task4.o
.data+0x2): multiple definition of `__heap_start'
./ex_init4.o.data+0x2): first defined here$ grep -R __heap_start
noscfg.h: * ::__heap_start and ::__heap_end must be provided and initialized
noscfg.h:extern void *__heap_start;
inc/pos_nano.h: * it is required to set the variables ::__heap_start and
Binary file Release/ex_init4.o matches
Release/PicoOS_task1.map: 0x000000000080006b __heap_start
Release/PicoOS_task1.map: 0x000000000080465b PROVIDE (__heap_start, .)
Binary file Release/ex_task4.o matches
Binary file Release/src/nano/n_mem.o matches
ex_init4.c:void *__heap_start = (void*) &membuf_g[0];
src/nano/n_mem.c: freeBlockList_g = (BLOCK_t)(void*)MEM_ALIGN((MEMPTR_t)(__heap_start));???
-
Karma
félisten
Sziasztok!
Suliban kaptunk egy ilyen kiinduló anyagot, amit tovább kellene fejleszteni:
#include "stdafx.h"
#include <stdio.h>
#include <time.h>
#include <conio.h>
int main()
{
unsigned char ch=0;
do {
if(_kbhit())
{ ch = getchar();
switch(ch)
{
case 0x00: printf("\n[Fx] code:");
printf("%d\n",getchar());
break;
case 0xE0: printf("\n[Xx] code:");
printf("%d\n",getchar());
break;
case '1': printf("Ahoj");
break;
case '2': printf("Hello");
break;
case 13 : printf("\n");
break;
default: printf("%c",ch);
}
}
} while(ch != 27);
printf("\n\nVege...\n\n");
return 0;
}A normál gombokat beolvassa gond nélkül, de az F1,F2,... ESC és tsa. már nem megy át. Hol a hiba? Mit nem veszek észre?
-
Hali!
Tombot szerertnek sorba rendezni. Legvegsobb esetben megirnam magam az algoritmust, de azert erdekel, hogy van-e direkt az en problemamra mar letezo algoritmus.
Van egy tombom, aminek minden eleme egy pointer egy strukturara, amiben van egy int, ami szerint rendezni kell. qsort() segitsegevel sorba is tudtam rakni a tombot, viszont nagyon fontos lenne, hogy ha ket elemben az a bizonyos int _egyenlo_, akkor a sorbarendezes utan megmaradjon az _eredeti_ sorrend. Szoval ha a 2. es a 7. elem erteke is pl 9, akkor a rendezett tombben eloszor a 2., utana pedig a 7. elem szerepeljen. Utanaolvastam a quicksortnak, ami ugy feldarabolja a tombot es aprankent rendezi (ha jol ertettem) ami miatt az utobbi kriterium nem teljesul. Valami otlet?Ha nem lenne megfelelo beepitett sorbarendezesi funkcio, akkor gondolom ugy kellene csinalnom, hogy vegigjarom a tombot n! - szor es minden iteracioban megkeresem a legnagyobb szam elso helyet amit aztan elore teszek..vagy volna egyszerubb megoldas is?
-
typedef struct bitfield
{
unsigned bit7:1;
unsigned bit6:1;
unsigned bit5:1;
unsigned bit4:1;
unsigned bit3:1;
unsigned bit2:1;
unsigned bit1:1;
unsigned bit0:1;
} bitfield_t;Ennek a sizeof() szerint miért 4 byte a mérete?
function xxxx (unsigned char num)
{
bitfield_t* mask = (bitfield_t*)#
.......
}1 byte-os adatra mutatok egy olyan mutatóval amely a fordító szerint 4 byte-os "blokkokat értelmez"...
Lehet ebből gond? -
Karma
félisten
De algoritmus alapján így sikerült, és nem tudom, hogy hol a hiba
Elkezdtem szerkeszteni a hozzászólást, csak közben spontán meeting lett
Van egy nagyon súlyos hiba: 1-től indexeled a tömböt, nem pedig 0-tól. Ezzel az első elem kimarad az összehasonlításokból, így hülyeség a vége.
A fordított sorrend, amit bizonyára tapasztalsz, az meg azért van, mert a belső ciklusodat nem az első elemtől, hanem i+1-től kell indítani. Enélkül amellett, hogy túl sokszor mész végig a teljes tömbön, még egyszer megfordítod az egészet...
Ha ezt javítod (0-tól kezdeni a külső, i+1-től a belső ciklust), már működő négyzetes lépésszámú (azaz lassú) rendezést kapsz.
De nem lesz ettől még buborékrendezés, mert annak a sajátossága, hogy az összehasonlítások és cserék mindig szomszédos elemek között történnek (pl. J és J+1).
Papírforma szerinti kiválasztásos rendezéssé könnyebb átalakítani, ha nem cserét végzel a belső ciklusban, csak megjegyzed a legkisebb szám indexét, és a belső ciklus után csinálsz egy cserét az i. és a minimumelem között. De annyira nem kritikus.
-
Karma
félisten
for (i=1;i<101;i++)
{
for(j=1;j<101;j++)
{
if (a[i]>a[j])
{
csere=a[i];
a[i]=a[j];
a[j]=csere;
}
}
}Ez Buborék rendezés nem?
Nem, akkor lenne buborék rendezés, ha a szomszédos elemeket cserélgetnéd.
Ez most egy sok felesleges kört futó valami -
Karma
félisten
(#3908) kispx
Amúgy nem az include -on van most a hangsúly mert kispx jól mondta, hogy nincs benne, nekem az a kérdésem, hogy milyen módon lehet beletenni? Kellene írni egy header-t hozzá?
Egy egyszerű Windows alatti megoldás, ha fogod az econio forrását, és együtt fordítod a programoddal. Nem véletlen, hogy Czirkos is ezt ajánlja
A C Free-t nem ismerem, de biztos van valami egyszerű módja, hogy a projektedhez add.
-
Karma
félisten
Azt, hogy az általam megrajzolt labirintus falára ne tudjon rámenni a játékos azt hogyan lehetne megcsinálni.
Nekem úgy sikerült, ha rá akar menni akkor visszadobja az elejére. Máshogy nem sikerült. Egy egyszerű megoldás, ha a koordináták azonnal léptetése előtt megnézed, hogy lehetséges-e az adott lépés (korlát, pályaszéle, akármi), és ha nem, akkor nem állítod be
-
Sziasztok!
A múltkori struktúrás kérdésemre kapott válaszokat köszönöm. Sajnos valamiért nem akart összejönni a dolog, így kicsit módosítottam a dolgokon.
Adott egy .c fájl amiben megvalósítom a meghívható get_Signal függvényt
ennek a paramétere egy struktúrára mutató pointer, amiben át kell adnom egy lokálisan tárolt struktúrát, aminek az értékeit csak egyszer adom meg és onnantól ne lehessen módosítanisignal.h:
typedef struct{
Signal_Types name;
uint16_t id;
uint8_t pos;
uint8_t length;
uint8_t order;
float factor;
float offset;
}Signal_TypeDef;
signal.c
static Signal_TypeDef SIGNALS[9];
uint8_t CAN_Signal_Init()
{
SIGNALS[NEW_SIGNAL_12].name = NEW_SIGNAL_12__NAME;
SIGNALS[NEW_SIGNAL_12].id = NEW_SIGNAL_12__ID;
SIGNALS[NEW_SIGNAL_12].pos = NEW_SIGNAL_12__POS;
SIGNALS[NEW_SIGNAL_12].length = NEW_SIGNAL_12__LENGTH;
SIGNALS[NEW_SIGNAL_12].order = NEW_SIGNAL_12__ORDER;
SIGNALS[NEW_SIGNAL_12].factor = NEW_SIGNAL_12__FACTOR;
SIGNALS[NEW_SIGNAL_12].offset = NEW_SIGNAL_12__OFFSET;
...
}
uint8_t get_Signal(SignalName name, Signal_struct** signal)
{
*signal = &SIGNALS[name];
}
main.c:
Signal_Struct* signal;
get_Signal(NWE_SIGNAL_12, &signal);
signal->id = 0x200; //ez ne tudjon lefutni vagy jelezzen a fordító hibátAz utolsó sort kellene valahogy megoldanom, hogy ne tudjak a struktúrába módosítani.
-
Karma
félisten
a folyamatos mozgás (game loop)
-
Karma
félisten
Azt hogyan csinálom meg, hogy egy test folyamatsan mozogjon mint pl. egy snake játékban. Ha kérhetném csak a mozgásban adjatok segítséget a többit magamtól szeretném
-
Lenne egy fontos kérdésem:
Van egy rendező függvényem, ami ABC sorrendbe rendezi egy láncolt lista elemeit strcmp stringkezelő függvénnyel.
Viszont ezzel az a baj, hogy a kis és nagy betűket és az ékezetes betűkkel hadilábon áll.
Tehát a nagybetűseket előreveszi, utána jönnek a kisbetűsök névsorrendbe és utána a az ékezetes betűvel kezdődőek.
Ezt hogy lehetne valahogy kijavítani?
A kis és nagybetűs dolgon már dolgozok. A bekért név első betűit nagybetűsítem, így nem lesz belőle baj, de egyelőre még csak az első karaktert tudtam nagybetűsíteni, a szóköz után nem.
Itt mi lehet a baj?uj->nev[0] = toupper(uj->nev[0]);
char *hely= strchr(uj->nev, ' ');
toupper(hely+1);Az utolsó sor tudom, hogy nem jó, csak igazából a memóriacímét adja vissza, nem pedig a a sztring valahányadik karakterét. :\
Előre is köszi!
Hátde az első sorban megírtad a megoldást, miért nem használod ugyanezt a szintaktikát a nullától különböző indexre?
Egyébként halálfejesen rossz megoldás, mert túlindexeléssel reccsen, ha a string végén szóköz van. Miért nem touppereled meg az egész stringet rendezésnél? Megspórolod a szóközkereső mágiát.
Másrészről viszont az ékezetes karakterekkel csak a baj van. Ezt a problémát már sokszor megoldották a világban, úgy nevezik, hogy collation.
-
Röviden ennyi a set-get. Nem működik teljesen jól, de az elv jól látszódik. Mivel úgy írtad, hogy a sokból két változó nem változhat, így a const-os dolgot nem lehet használni, mert akkor egyik elemét sem lehet változtatni. Valamiért nem a 10-t tölti bele a változóba. Tudja esetleg valaki, hogy miért?
#include <stdlib.h>
#include <stdio.h>
typedef struct
{
int ifoo;
char cfoo;
} fooTypeDef;
void set(fooTypeDef foo)
{
foo.ifoo = 10;
}
int get(const fooTypeDef foo)
{
return foo.ifoo;
}
int main(void)
{
fooTypeDef sfoo;
set(sfoo);
printf("%i\n", get(sfoo));
return 0;
}Látom pointereket használsz. Ha azok sem változnak, akkor arra is ki lehet kötni, hogy konstans legyen.
MCU-ra vagy a PC-re írod a kódod?
Bocsi, hogy csak most válaszolok, de a munkahelyen nem szeretek 1-2 percnél többet foglalkozni a fórummal.
-
Sziasztok!
Egy kis segítségre lenne szükségem C-s téren.
Adott egy struktúrám, amiben van mindenféle változó. Azt szeretném hogy ezeknek a változóknak csak egyszer lehessen értéket adni, és utána ne lehessen megváltoztatni.
A dolog érdekessége hogy a struktúrából létrehozok egy tömböt és egy függvényen belül adok értéket a struktúrák elemeinek. Ha az elemeket const-al deklarálom akkor beszól a fordító hogy read-only value.
Van valami megoldás erre a problémára?Köszi a segítséget
-
Najó, ez csak pedantéria, és ahogy nézem Linuxon nincs is rá szükség - az IGNPAR flaggel az egész hibakezelést ki lehet hagyni a képletből.
(Tök izgalmas ez a feladat
Kár hogy nem tudok kísérletezni ilyennel élesben. Bár lehetne íeni egy szimulátort FPGA-ra, ami ezeket a jeleket tolja ki.) -
Szerintem inkább SPACE paritás kéne, akkor kevesebb hiba generálódik (a datagram kezdőbyte-oknál).
A linkelt oldalon van is erre egy Visual Basic kód (a DOS-os közvetlen UART programozáson túl, amire manapság AFAIK már nem nagyon van lehetőség), tegnap este jól belealudtam az olvasásába.Najó, ez csak pedantéria, és ahogy nézem Linuxon nincs is rá szükség - az IGNPAR flaggel az egész hibakezelést ki lehet hagyni a képletből.
(Tök izgalmas ez a feladat
Kár hogy nem tudok kísérletezni ilyennel élesben. Bár lehetne íeni egy szimulátort FPGA-ra, ami ezeket a jeleket tolja ki.) -
Beállítod valamelyik paritást és a PARMRK opciót. Ez alapján már tudod rekonstruálni a 9. bitet.
Szerintem inkább SPACE paritás kéne, akkor kevesebb hiba generálódik (a datagram kezdőbyte-oknál).
A linkelt oldalon van is erre egy Visual Basic kód (a DOS-os közvetlen UART programozáson túl, amire manapság AFAIK már nem nagyon van lehetőség), tegnap este jól belealudtam az olvasásába. -
sziasztok!
a következő problémámban kérném a segítségeteket: vadászom hogy hogyan tudnék lekezelni egy speciális soros protokolt, ahol van egy 9dik adatbit is, ami azt mondja meg hogy új csomag kezdődik. PIC-el nem nagy mutatvány, ott az újabb típusokon erre van egy plussz regiszter amit lehet paritásként vagy 9dik adatbitként szoftverből írni/olvasni. viszont ahogy látom, ez nem igazán megoldott PC-s környezetben, de ezt találtam rá, mint szoftveres hack: [link] - néztem az alul linkelt libmip oldalt és az onnan letölthető csomagot is. a küldés részt azthiszem sikerült megértenem - megtaláltam a mip/MipBus.cpp-ben a 160-dik sortól. nekem viszont az írás nem kell, az olvasása viszont annál inkább. ezt eddig nem sikerült felfognom, átlátnom... valaki aki kicsit jártasabb a témában tudna segíteni kitúrni? erősen kezdő vagyok még C-ben ( eddig leginkább pascal / delphi / php -vel foglalkoztam ), de ezt szeretném összehozni. ami még tovább árnyalja majd a történetet az az, hogy végül egy OpenWrt-s MR3220-as routerre szeretném ráfordítani, de első körben PC-n szeretném látni hogy működik...
előre is köszönöm a segítséget!
locks cannot find/run the compiler.
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Pont arra gondoltam. A szoftveres "luxus" hiánya (OS, driverek, stb.) szerintem gyorsan megugorható, fel se merült bennem, hogy valaki úgy akarna uC-t programozni.
.
Új hozzászólás Aktív témák
● olvasd el a téma összefoglalót!
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- Autós topik
- Wise (ex-TransferWise)
- Mesterséges intelligencia topik
- Visszatérés az aranykorba: Heroes of Might and Magic: Olden Era Early Access
- Külföldi prepaid SIM-ek itthon
- E-book olvasók
- Hitelkártyák használata, hitelkártya visszatérítés
- Építő/felújító topik
- VGA kibeszélő offtopik
- Samsung Galaxy S25 - végre van kicsi!
- További aktív témák...
- Mac Pro 6,1 2013 Late
- GAMER PC! i7-14700 / RTX 5080 / 32GB DDR5 / 1TB NVMe / 1000w Gold / BeszámítOK !
- ASUS ROG Strix SCAR 16 / Ultra 9 275HX / RTX5090 / 32GB / 2TB NVMe! BeszámítOK
- 27% - Corsair RMx Series RM1000x 1000W 80 PLUS Gold (CP-9020271-EU) Tápegység!
- White AM4 félkonfig! ASUS ROG B550-A + Ryzen 9 5950X BOX + 32GB DDR4 3600Mhz CL17
- Keresünk iPhone 16/16e/16 Plus/16 Pro/16 Pro Max
- REFURBISHED és ÚJ - HP Thunderbolt Dock 230W G2 with combo cable (3TR87AA)
- Dell Precision 5560,15.6",FHD+, i7-11850H,16GB DDR4,1TB SSD,Nvidia T1200 4GB VGA,WIN11
- 14" Dell Latitude laptopok: 5400, 5480, 5490, 7480, 7420, E6410, E6440, E5450 / SZÁMLA + GARANCIA
- SzoftverPremium.hu
Állásajánlatok
Cég: aiMotive Kft.
Város: Budapest
Cég: Laptopműhely Bt.
Város: Budapest