Hello

Elmétek kiapadhatatlan tudás forrását, szeretném ismételten megcsapolni

Lenne egy olyan problémám, hogy a tömb nevét szeretném változtatni attól függően milyen betűtípust akarok használni. Font neven fut, és ha változóval próbáltam helyettesíteni nem ment.
Gondolom van rá megoldás, csak nekem új

Előre is köszönöm

Ez lenne a példa részlet:
int write_char(int page_select, int y_offset, int charcater_code)

{ int x;
if(y_offset>=( Display_width/2) && y_offset <= Display_width - Font_width && charcater_code>=32 && charcater_code<=128) //Check which side of the screen need to be activated
{
goto_xy( page_select, y_offset);

for(x=( charcater_code - Font_offset ) * Font_width; x<(( charcater_code - Font_offset)* Font_width)+ Font_width; x++) //Decodes the character code and make sure the data is sent by 8 bits
{
send_data_screen( Font[x]); //Sends out the relevant section of the Array
}
} else if( y_offset<( Display_width/2) && y_offset>=0 && charcater_code>=32 && charcater_code<=128)
{
goto_xy( page_select, y_offset); //Selects pages of writing
for(x=( charcater_code - Font_offset)* Font_width; x<(( charcater_code - Font_offset) * Font_width)+ Font_width; x++) //Decodes the character code and make sure the data is sent by 8 bits
{ if( y_offset + (x-( charcater_code - Font_offset) * Font_width)!=( Display_width/2)) //Checks if the character has reached the border of the 2 sides of the screen
{
send_data_screen( Font[x]);
}
else
{ //If the Character is belong to the right side
goto_xy( page_select,( Display_width/2)); //Selects pages of writing
send_data_screen( Font[x]); //Sends out the relevant section of the Array


}
}
}
else
{
MEMBRANE_MUTE=1;

}

}

[ Szerkesztve ]

Ha jól értem, paraméterben szeretnéd átadni a write_char() függvényednek azt, hogy milyen betűkészletet használjon. Ehhez össze kell szedned, mi definiálja a betűkészletet. Egyrészt a Font[] tömb, másrészt a Font_width, Font_height, Font_offset (ha nem hagytam ki valamit). Ezeket fel kell venned még plusz paraméterként és átadnod a write_char()-nak, pl:

int write_char(int page_select, int y_offset, int character_code,
long int *font, int font_width, int font_height, int font_offset)

És így tudod pl. meghívni:

write_char(line,y_offset+j*Font_width,test[j],Font,Font_width,Font_height,Font_offset);

Mivel az y_offset számolásában is használod a Font_width-et, így szebb lenne ezt a függvényen belül végezni.

Ha pedig mindegyik betűkészlet ugyanolyan méretű, akkor elég csak a font tömböt átadni, nem kellenek a betűméretek.

Hello,

Sry, hogy ide, de itt legalább van élet. (Dobjátok át másikba, ha nem fér el itt )
Valakinek van ötlete, hogy hogyan lehetne Androidon, Camera2 API -ból a preview tulajdonságait lekérni? Konkrétan az AWB_STATE_LOCKED, és az AE_STATE LOCKED kéne, amit mindenhol csak Capturerequest-ből látok lekérdezni, csahogy az én programomban nincs Capturerequest mert nem ment képet, csak a preview-ből jövő képeket dolgozza fel

Köszi bármilyen ötletet

Mutogatni való hater díszpinty

Köszönöm

Valahol láttam, de nem tálalom, egy olyan megoldást ahol külön h ban tároltak minden fontot, és talán struct megoldással átvették mindig az aktuális tömböt, és a hozzá tartozó magasság és egyébb paramétereket.

Erre lenne ötlet?

Előre is köszönöm

Persze, teheted a font paramétereket egy struktúrába, és akkor elég átadni erre a struktúrára mutató pointert a font választáshoz (vagy csúnyább esetben mehet az egész egy globális változóba). Pl:

#include "font1.h"
#include "font2.h"

struct font_type
{
long int *font;
int font_width;
int font_height;
int font_offset;
};

struct font_type myfont[2];

myfont[0].font = Font1;
myfont[0].font_width = Font1_width;
myfont[0].font_height = Font1_height;
myfont[0].font_offset = Font1_offset;

myfont[1].font        = Font2;
myfont[1].font_width  = Font2_width;
myfont[1].font_height = Font2_height;
myfont[1].font_offset = Font2_offset;


int write_char(int page_select, int y_offset, int character_code,struct font_type *use_font)
{
...
send_data_screen(use_font->font);
...
}

write_char(line,y_offset+j*myfont[0]->font_width,test[j],&myfont[0]);

write_char(line,y_offset+j*myfont[1]->font_width,test[j],&myfont[1]);



De lehet, hogy jobb lenne az y_offset paramétert szétszedni egy y és egy j paraméterre, és a font_width-tel való szorzást beletenni a függvénybe, hogy ne kelljen azt is font-tól függően átadni:

int write_char(int page_select, int y, int j, int character_code,struct font_type *use_font)
{
int y_offset = y+j*use_font->font_width;
    ...
    send_data_screen(use_font->font);
    ...
}

Köszönöm

Az y_offset át kell hogy nevezzem mert megtévesztő, ez az x tengelyen való eltolást jelöli, semmi dolga nincs magával a fonttal, vagy nem teljesen értelek

Próbáltam utána olvasni a struktúrának, egyenlőre nem vagyok vele meg kibékülve, de dolgozom rajta

A másik dolog amin ügyeskedek, a font magassága se jelentsen problémát, vagyis képes legyek több memória lapra kivetítve is elküldeni az adatokat. Arra mar rá jöttem, a font sima decimálisban van(olyat találtam mind a 16 bit egy számot alkot, ami a magasságát teszi ki a karakternek), akkor egyszer 8 pozíciót jobbra, máskor 8 pozíciót balra kell tolni és maris megvan a 8-8 bit, vagy legalábbis remélem

A memória olvasást megoldottam, így mar tudok 1 db pixelt bárhol kapcsolni, anélkül, hogy befolyásolnám az adott lapon levő többi pixelt

Köszönet a segítségért meg egyszer

[ Szerkesztve ]

Arra gondoltam, hogy egy korábbi hozzászólásodban így hívtad meg a write_char-t:

for(j=0;j<=i-1;j++) write_char(line,y_offset+j*Font_width,test[j]);

És ebben a második paraméterben használod a Font_width-et is, ezt lehetne kiiktatni, ha egy struktúrában úgyis átadod a font paramétereket. Ehhez át kellene alakítani egy kicsit a paraméterezést (pl. ahogy javasoltam: kettéválasztani egy y és egy j paraméterre, és a write_char függvényen belül elvégezni az y+j*Font_width számolást).

Az a string kiiratas most már értem.

Most már értem, a karakter kiírásban, az y_offset a koordinatat határozza meg, a string kiiaratasban, meg ugye léptetését kell csinálni, hogy ne egymásra írja a karaktereket. Vagyis SZVSZ nem tudok vele semmit csinálni, hiszen van ahol csak 1db karaktert akarok kiiratni, akkor pedig nem működne ha jól sejtem

Ahogy többet gondolkodom, egyre jobban értem miért hoztad fel

Akkor kellene még egy paraméter, ami megmondja hányadik karakter a referencia koordinátától. Vagyis ha a szorzata 0 akkor lényegtelen

Tetszik, csak nehezen értettem meg. Elnézést

Sziasztok!

TLS libekkel van valakinek közelebbi ismeretsége?

Egy közepes teljesítményű tcp szervert raknék össze (jellemzően linux), és ha lehet, C libeket használnék. Amit neten találni tudtam viszonylag friss nevet, az az openssl, de a c sdk-ja környékén (pld wiki page-en [link] ) olyan hírek vannak, hogy nem thread-safe a design, és az csúnya hátrány. Kellene nekem tcp stream codernek legalább 6-8 szál folyamatosan. Nem ártana egy normális összefoglaló leírás is, mert szálazni c-ben találomra - szóval az azért nem egészen úgy megy.

Ha valaki már küzdött meg hasonló problémával, örülnék az utólagos statisztika tapasztalatának. Az alternatíva dotnet core-t használni, de lévén temérdek sok apró csomagot kell majd kezelni, a gc nagyon csúnya hátrány lenne, a dot c-t azért hanyagolnám.

កុំភ្លេចប្រើភាសាអង់គ្លេសក្នុងបរិយាកាសអន្តរជាតិ។

A linkelt thread safety problémák az 1.0.x openssl verzióra vonatkoznak, de 1.1.0 óta már nem kell locking callbackeket definiálni.

Halál a CLI interfésze és halál a dokumentációja is. Persze mindent lehet csak idők kérdése.

Érdemes elésben használat előtt szeparált környezetben kitesztelni mindent.

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

@kovisoft @buherton:

Most kotortam végig openssl doksikat amazonon, és nincs egy deka jelenkori könyv sem az sdk-ról

Kellene egy tapasztalt tanács. Ha amúgy nem vagyok agyhalott programozáshoz, meg dokumentációk megértéséhez, mennyi időt fogok vélhetően rászánni, mire átlátom, hogy mit tud a lib és mit nem?

កុំភ្លេចប្រើភាសាអង់គ្លេសក្នុងបរិយាកាសអន្តរជាតិ។

Úgy kell neki állni, mint egy normál programozási feladat. Nézzük meg mit csinált más .

Mielőtt beleugranál a programozásba érdemes kézzel kipróbálni azt, amit végül csinálni akarsz. Ehhez először olvass el néhány releváns how-to-t. Ezzel ki fogod ismerni magad a kulcsok világában és hogy az openssl-el ez hogyan működik. És megismered a hibaüzneteket, no meg azok formátumát .

Ha ez megvan akkor érdemes megnézni a példa programokat. Például: Darrenjs [link]

A githubon találtam még régebben valahol egy nagyon jó example-t, amiben több formátumú kulcsra is voltak különféle példák.

Az openssl-nek van a neten dokumentációja, de szerintem rossz az elnevezés, mert az inkább egy referencia.

[ 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... !!!

Köszönöm a példa linket.

Van esetleg olyan szerver / kliens példa is valahol, ahol a server ténylegesen működik végtelenített echo funkcióval, és minden lépésnél kiírja, ami kliens oldalról éppen érkezett? A linkelt példa csak külső héj, tényleges adatkezelés nincs benne, csak a berkeley socket alapjai, amit megtalálok bárhol.

Az sha-nak a stream kódoláshoz folyamatosan változó kódolási állapota van. Az ember azt hinné, hogy a socketnak van egy kontextus állapota, amit tudni kell menteni / visszatölteni abban az esetben, ha egy thread-en nem csak egy socket-ot kezelek, hanem sokat. Vajon olyan példa is akadhat valahol?

កុំភ្លេចប្រើភាសាអង់គ្លេសក្នុងបរិយាកាសអន្តរជាតិ។

Létezik fizetős licencelt C SSL sdk?

កុំភ្លេចប្រើភាសាអង់គ្លេសក្នុងបរិយាកាសអន្តរជាតិ។

Helló, egy tweetben láttam egy ilyet:

A kód picit csinosítva ez:

#include <stdio.h>

int fun(par)
int (*par)();
{
return (*par)();
}

int sub()
{
return 12;
}

int main()
{
int sub();
int var = fun(sub);
printf("%d", var);
}

Dolgok, amiket nem igazán értek:
1/ int sub();
Ez gondolom függvénypointer definiálás akar lenni, de akkor nem kellene csillagozni?
2/ Az elején nem értem azt a konstrukciót:
int fun(par)
int (*par)();
Ez mi az isten? Tehát ha le van zárva pontosvesszővel, akkor utána miből returnölünk?

I did nothing, the pavement was his enemy!

1/ int sub();
Ez egy forward declaration, arra szolgál, hogy ha majd csak később lesz ténylegesen definiálva a függvény, amit már előtte használni akarsz, akkor ebből tudja a fordító, hogy milyen argumentumai vannak és milyen típusú értéket ad vissza. Mivel te áthelyezted a sub() függvényt a main() elé, így a te változatodban nincs rá szükség.

2/ Egy függvény argumentumait deklarálhatod úgy is, hogy rögtön odaírod a nevük elé a típusukat, de úgy is, hogy csak a nevüket írod a zárójelbe, a típusukat ekkor külön meg kell adni a zárójel után és a nyitó kapcsos zárójel előtt. Jelen esetben a fun() függvénynek egy par nevű argumentuma van, aminek a típusa egy int-et visszaadó argumentum nélküli függvénypointer. Ennek lesz majd átadva a sub() itt: fun(sub)

Ahh, köszi. Munkában el vagyok kényeztetve az egyszerű kódokkal.

I did nothing, the pavement was his enemy!

Megvan az a szöveg valami normálisabb digitális formában? A teljes blog.

កុំភ្លេចប្រើភាសាអង់គ្លេសក្នុងបរិយាកាសអន្តរជាតិ។

Itt láttam: [link]

I did nothing, the pavement was his enemy!

A jelek szerint csak akkora a kép. Mindössze kíváncsiságból kérdeztem meg utána kotorni, hogy ugyan mi oka lehet valahol a népeknek azt a szintaktikát használni. Ha szétszedik a fejlécet változónként egy sorra, ugyan úgy rugalmasabban szöveg-szerkeszthető eredményt kapnak, és áttekinthetőbben.

កុំភ្លេចប្រើភាសាអង់គ្លេសក្នុងបរិយាកាសអន្តរជាតិ។

Az itt jelenlévők közül futott már valaki köröket a [WolfSSL] libbel ? Főleg linuxon szerver oldali aszinkron stílusban. Dokumentáltabbnak tűnik, mint az openSSL, de a felépítési alapelve szerintem gyengébb (összedrótozták a platformra jellemző socket kezelést a cipherrel ahelyett, hogy csak egy független cipher libet adnának), és kérdéses, hogy tényleg minden részletet kidolgoztak-e.

[ Szerkesztve ]

កុំភ្លេចប្រើភាសាអង់គ្លេសក្នុងបរិយាកាសអន្តរជាតិ។

Ez egy meglehetősen régi példa lehet.
2/ A példában régi stílusú argumentum deklarálást látsz, ezt már az újabb fordítók meg sem engedik..

„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár

Sziasztok,

Egy kis segítség kellene, sehogy sem tudom megoldani, hogy amint a main.c fájlban definiáltam makrót az elérhető legyen egy include-ban lévő include-ban.

pl.:

main.c:
#include "elso.h"
#define TEST 0

void main(void)
}
 bla-bla
}

elso.h:
#ifndef masodik.h
  #include "masodik.h"
#endif

És ha a masodik.c -ben hivatkozok a TEST makróra akkor azt a hibát dobja, hogy nincs definiálva. Szóval elso.c -ben még elérhető a makró de a második.c-ben már nem...

Valami tanács?

Azért nem látja, mivel az include a define előtt van. A preprocesszor soronként megy végig a file-on, egyszer.
Egyszerűen cseréld fel a main.c első két sorát és jó lesz.

DRM is theft

Már próbáltam. Nem használ.
Én is így emlékeztem de mindegy, hogy elé teszem vagy mögé, az első include látja a második nem.

Ha azt akarod, hogy mindkét .c file-ban lásd a makrót, akkor egy olyan headerben kell definiálni, ami mindkét .c-be include-olva van.

Ha jól értem csináljak mondjuk egy config.h-t amibe benne van a #define TEST 0 és ezt a headert kell beincludolni a main.c, első.c, masodik.c -be?

Így van, ez pl. egy lehetséges megoldás. De a config.h a többi olyan include előtt legyen, ami használja a TEST makrót.

A lényeg, hogy amelyik .c-ben (vagy .c-be include-olt .h-ban) használni akarod a makrót, oda előtte már valahogy bekerüljön. Amit közvetlenül a main.c-be írsz be, azt nem látja az elso.c vagy a masodik.c. Tehát vagy mindegyik .c-be beírod a definíciót, vagy egy olyan .h-ba, ami include-olva van mindegyik .c-be. Nyilván ez utóbbi a szebb megoldás. A .c-be olyan esetben célszerű beírni, ha ettől a makrótól függ valami működés, és különböző .c-kben eltérő definícióra van szükség (pl. egyik .c-ben a TEST értéke 0, egy másikban 1).

Ha lehet inkább használd a

#ifndef
#endif

Makrót, mert ha végig include-olod a forrásfájlokat,tulajdonképpen teleszemeteled a fájlodat.

Magyarul így minden forrásfájlba:
#ifndef config.h
   #include "config.h"
#endif

A precompiler, meg mint tudjuk nem buta.

[ Szerkesztve ]

Remélem itt elfér - https://sites.google.com/site/geriprojekt/ - https://github.com/kgregoryan - Az ember téved,a gép hibázik.

Sziasztok!
Lenne egy Linux C/C++ programozási kérdésem, de lehet nem is annyira a C/C++ nyelv a lényeg benne, Linux kernel v4.x-et használok.

A kérdés az, hogy amikor C/C++-ban a pthread.h-et használva indítok egy plusz threadet FIFO ütemezésben úgy, hogy előre attribútumban beállítom neki a CPU affinitást minden magra, a futás közben ezt a Linux hogy fogja figyelembe venni és kezelni? A thread amit indítok egy végtelen ciklusban figyelget egy thread-safe queue-t, és amikor van valami új elem azt kiveszi, majd csinál vele egy két műveletet, aztán megint blockolva várja a következőt. Ez a szál teljesen jól működik, kb 3-4%-os CPU használatot eredményez, de számomra nagyon gyanús az, hogy mintha a Linux véletlenszerűen indítaná az egyik magon a sok közül ezt a threadet, és utána örökké, csak azon a magon futtatja, vagyis a blockolás feloldása után mintha sose lenne olyan, hogy a másik magra kerülne át a futtatása, pedig a másik magon több szabad CPU idő lenne láthatóan htop-ban. Tud valaki valami infót vagy valami jó linket, hogy valami nagy könyv/biblia szerint a több magot is használható threadeknek hogy kéne managelődni a Linuxban a CPU magok között?

Gigabyte GA-Z170-D3H, Intel Core i7-7700K, Corsair Vengeance 2x8GB DDR4-3600MHz, Intel 545s 256GB SSD, EVGA GeForce GTX 1060 GAMING 6GB

Sziasztok, valaki ránézni, hogy mit rontok el? Nem jövök rá mi a baj. Az is lehet, hogy több sebből vérzik a dolog, egy ismerősnek próbálok segíteni vizsgára készülni, de hát eddig vak vezet világtalant Első félében C-vel veszik a kedvüket egy életre a programozástól (gépész ráadásul)

Egy 2D-s tömböt kéne feltölteni, ez lenne egy feladat eleje. A sorok számát kell bekérni, oszlop szám adott, és utána az értékeket.

#include <stdio.h>
#include <stdlib.h>

#define OPEN_HOURS 5

int main (void) {
    
    int statDay = 0;
    printf("Hany nap adatait visszuk be? ");
    scanf("%d", &statDay);

    int (*statData)[statDay][OPEN_HOURS]= malloc(sizeof(int[statDay][OPEN_HOURS]));

    for (int i = 0; i<statDay;i++) {
        for (int j = 0; j<OPEN_HOURS;j++) {
            printf("Kerem az %d. nap %d elemet: \n", i,j);
            scanf("%d", &statData[i][j]);
        }
    }

    printf("\nKiiras\n");

    for (int i = 0; i<statDay;i++) {
        printf("%d. nap:\t", i);
        for (int j = 0; j<OPEN_HOURS;j++) {
            printf("(%d;%d) %d\t", i,j, statData[i][j]);
        }
        printf("\n");
    }    

    free(*statData);
    
    return 0;
}

Látszólag működik is a dolog, de a tömbben rossz helyre kerülnek az értékek és nem jövök rá miért. Ha pl 0. napra 0, 1, 2... az 1. napra 10, 11, 12-t írok akkor ezt kéne kiírnia:

0: 0 1 2 3 4
1: 10 11 12 13 14

de helyette ez van:

0. nap: 0       1       2       10      11
1. nap: 10      11      12      20      21
2. nap: 20      21      22      23      24

0. napon 3 és 4 helyett 10 és 11 van, 1. napon 13 és 14 helyett 20 és 21...

MZ/X

Szerintem a malloc sorral van a gond. Ahogy írtad, úgy eggyel több az indirekció a bal oldalon (pointer egy két dimenziós tömbre, ami így egy három dimenziós tömbbel lesz analóg). Helyette ez kellene:

int (*statData)[statDay] = malloc(sizeof(int[statDay][OPEN_HOURS]));

Másik lehetőség, hogy egy dimenziós tömböt használsz (szimpla pointert allokálsz) és [i*OPEN_HOURS+j] formában indexeled.

És a free-nél sem kell a csillag, csak simán free(statData).

Megnézem, de ennél a résznél kezdem elveszteni már a fonalat Pluralsight-on csinálom a C képzéseket, pont azt monta az oktató ennél a résznél, hogy ez a legegyszerűbb módja mert egyszerű utána felszabadítani a memóriát, és ugyan úgy lehet hivatkozni egy elemet, ahogy statikus 2D tömbnél. Neten- YT-n mindenhol a for ciklussal feltöltögetős verziót láttam, azért örültem meg ennek, de hát nem megy.

Amit írtál azt hogy kell elépzelni, nem teljesen értem. Egy sort ki tudok választani egy pointerre és egy elemet egy indexel?

[ Szerkesztve ]

MZ/X

Amikor egy szimpla 1 dimenziós tömböt allokálsz, akkor azt egy szimpla pointerbe rakod bele:

int *array = malloc(sizeof(int[ARRAY_SIZE]));

És utána array[i]-vel hivatkozol az elemeire. Ha ezt ki akarjuk terjeszteni 2 dimenzióra, akkor hozzáteszünk mindkét oldalhoz +1 dimenziót, de miért tennénk +2 dimenziót a bal oldalhoz?

int (*twod_array)[COLUMNS] = malloc(sizeof(int[ROWS][COLUMNS]));

Így a twod_array egy olyan pointer, ami "COLUMNS db integerből álló tömb" típusú adatra mutat, ilyenekből allokáltunk ROWS db-ot, és twod_array[i][j]-vel hivatkozunk az elemeire. Legalábbis szerintem így kell, de bevallom, nem próbáltam ki.

Viszont mint írtam, csinálhatod azt is, hogy te számolod át a 2 dimenziós indexet 1 dimenziósra, ekkor elég egy nagy 1 dimenziós tömböt allokálni:

int *simulated_twod_array = malloc(sizeof(int)*ROWS*COLUMNS);

Aztán így hivatkozol az i. sor j. oszlopára: simulated_twod_array[i*COLUMNS+j].

Ah, megvan, azt nem állítom, hogy pontosan értem de működik:

Ez nem jó:
int (*statData)[statDay] = malloc(sizeof(int[statDay][OPEN_HOURS]));

Ez ok, szépen lehet indexelni, adatok a helyükön.
int (*statData)[OPEN_HOURS]= malloc(sizeof(int[statDay][OPEN_HOURS]));

Nagyon köszi a segítséget

MZ/X

Ja igen, sorry. Ez volt még a másik dolog, ami közben eszembe jutott, hogy a sorok és az oszlopok lehetnek felcserélve a deklarációban, és sajnos az enyémben is. Jobban belegondolva akár a te változatod is működhet, ha felcseréled a sorokat és az oszlopokat.

Megpróbáltam lefordítani az eredeti kódodat, de nekem (treat warnings as errors beállítással) fordítási hibát dobott a scanf és a printf sorokra. Érthető, mivel az int (*statData)[statDay][OPEN_HOURS] egy kétdimenziós tömbre mutató pointer, nem pedig egy kétdimenziós tömb. A statData[i][j] nem egy int-et, hanem egy pointert jelent. Cast-olással kierőszakoltam, hogy leforduljon, valamint felcseréltem a statData deklarációjában a sorokat és az oszlopokat (int (*statData)[OPEN_HOURS][statDay]), és így már ez a változat is működött.

Ökölszabályként azt tartsd szem előtt, hogy amikor egy pointert deklarálsz, akkor azt tömbként is tudod használni (meg tudod indexelni [i] stílusban), tehát úgy is felfogható a dolog, hogy egy * ugyanúgy hozzáad egy dimenziót a deklarált tömbödhöz, mint egy [SIZE]. Fordítva is igaz a dolog: egy tömb utolsó dimenzióját lehagyva egy pointert kapsz.

Vagyis amikor ezt írod le: int (*statData)[OPEN_HOURS][statDay], akkor ez igazából egy 3 dimenziós tömb, aminek az első két dimenziója a fix [OPEN_HOURS] és [statDay], a harmadik dimenziója dinamikus, és ennek mérete a malloc-ban megadott értékből jön, ami jelen esetben [1] (mivel a teljes allokált méret OPEN_HOURS*statDay*1). Éppen ezért az így deklarált tömb elemeire ezen a módon kell hivatkozni: statData[i][j][0]. Kipróbáltam ezt is, és így is működik. Ezzel együtt nem javaslom ennek a formának a használatát, és nem is értem, hogy a Pluralsight miért így tanítja.

Szia,

nagyon köszönöm a segítséget, azt hiszem most már értem, legalább ezt a részt

MZ/X

Sziasztok, kis segítséget kérnék.
Elkezdtem csak úgy érdeklődés szinten c-t tanulni mert érdekel. Az elején vagyok nagyon, gyakorlásképpen csináltam egy kis kódot:

#include <stdio.h>
#include <string.h>
int main ()
{
const char name[20];
const char restrictions[5] = "c";
printf("Enter name: ");
scanf("%s", name);

if (strstr(name, restrictions) != NULL)
{
printf("Not a valid name!\n");
} else
printf("Name: %s\n", name);

return 0;
}

Bekér egy nevet és megadott karakter esetén kiírja, hogy az nem megfelelő.Ezt szeretném tovább bővíteni úgy, hogy több nem megengedett karakter legyen. Úgy gondoltam ezt talán tömbbel lehet szóval a
const char restrictions[5] = "a" sort átírtam így const char restrictions[5] = {'a', 'b', 'c'}
na így viszont már nem igazán akar működni. Valaki tud elvi iránymutatást adni, hogy ez miért nem jó? Tömbbel már nem működik igy az strstr? Köszi

[ Szerkesztve ]

https://starcitizen.hu ha tudni akarod mi újság az univerzumban

Azért nem működik így, mert az strstr() egy összefüggő rész-stringet keres meg az adott stringben, te pedig azt szeretnéd, hogy a megadott karaktereket külön-külön nézze meg, hogy benne vannak-e valahol a stringben, nem feltétlenül összefüggően és nem feltétlenül ugyanabban a sorrendben. Pl. ha "abc"-t keresel, azt az strstr() megtalálja az "aabcc"-ben, de nem találja meg az "aabbcc"-ben, mert ez utóbbinak az "abc" nem rész-stringje.

Azt kell csinálnod, hogy egy ciklussal végigmész a restrictions[] karakterein, és mindegyikre megnézed, hogy benne van-e a name-ben az adott karakter.

Szerk: lassú voltam

[ Szerkesztve ]

Ahaaa, na talán kapizsgálom amit írtál. Köszi szépen, nekiesek majd és e szerint átírom Nem voltál lassú amúgy, elvi iránymutatást kértem azt megadtad, a fenti kódot még nem néztem meg. Majd ha nem sikerül megírnom akkor rálesek arra

https://starcitizen.hu ha tudni akarod mi újság az univerzumban

Ha karaktereket keresel egyesével stringben, akkor javaslom az strchr() használatát strstr() helyett, mert az strstr()-nek keresőstringet kell megadni, ezért nem fog működni const char restrictions[5] = {'a', 'b', 'c'} formával. Ezt láthatod is pmonitor kódjában, ha majd megnézed.

Csak úgy érdekességként:
#include <stdio.h>
 
int main (){
char name[20];
char chars[5]={'a','b','c','d','e'};
int yes=0;
    printf("Enter name: ");
   scanf("%s",name);
    for(int i=0;i<sizeof(name)/sizeof(char);i++){
        for(int j=0;j<sizeof(chars)/sizeof(char);j++){    
            if(name[i]==chars[j]){
                yes=1;}
                        }
                            }
printf("%s",yes?"YES\n":"NO\n");
    
    printf("%ld name",sizeof(name)/sizeof(char));
        printf("%ld chars",sizeof(chars)/sizeof(char));
         return 0;}

[ Szerkesztve ]

Remélem itt elfér - https://sites.google.com/site/geriprojekt/ - https://github.com/kgregoryan - Az ember téved,a gép hibázik.