Szerver kliens programkodja van valkinek?
C ben irt szerver kliens program amiben tobb kliens egy szerverrel komunikál.(egyszeru komunikacio . szoveg vagy számolás

Ablak méretek: [link]
Font: set -fs <pts>

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

Van konkrét kérdésed is?

Jester

Köszönöm, ez kellett nekem!

Azt nem tudom,hogyan hozzam ossze,hogy tobb kliens (5 cliens) egy szerverrel komunikaljon,...szoval hogy tudjanak egymas kozott szoveget kuldeni (Nem kell,hogy ot gepen legyenek osszehangolva,eleg ha ot terminalt nyitok linuxban es ugy....)

Tehát a szervernek a kliensek között kellene közvetíteni?

Jester

A cliens kuld valamit a servernek , a server tovabb kuldi egy masik kliensenk ami a kerest vegre hajtja majd vissza kuldi a szerver a kapott eredmenyt. (összeadást , pl. 1 + 1)

Ezen az oldalon van egy server-kliens

http://www.prasannatech.net/2008/07/socket-programming-tutorial.html

C tipusu
tcpserver.c
tcpcliens.c
Ezeket lefutattam,mukodnek (szoveget tudok kuldeni ide oda. Ubuntu alatt teszteltem)

[ Szerkesztve ]

Ebben a témában erősen ajánlom Brian "Beej" Hall cikkét: magyar változat, angol több formátumban. (ez alapján írtam "chat" szervert minden benne van)

Ez már olvastam de az elején még teccet,hogy nem definiciókként írja le a dolgokat. Csak a kozepe fele már elvesztem a szovegben. Masodszor is nekifutottam akkor már szinte mindent értettem. De a végén nem tudtam ossze hozni a programot. (chat programnál én is olvastam már egyszer ezeleott )

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

Persze hogy van, csak egy kicsit el kell rugaszkodnod a struktúrától. A megoldás az ún. getter/setter függvények írása, amivel szabályozod a hozzáférést.

Röviden írnod kell olyan függvényeket, melyeknek az első paramétere egy pointer a struktúratípusodra; a getternél nincs más, a setternél meg ott az új érték másodiknak. És csak ezeket a függvényeket használod a struktúrád birizgálásához, közvetlenül nem nyúlsz bele.

C-ben ezt egyébként elég könnyen garantálni is tudod, ha a struktúrád definícióját külön .c fájlba rakod.

“All nothings are not equal.”

Szóval a struktúrám össze elemére írnom kellene egy get és set függvényt?

Igen. Tulajdonképpen objektum orientáltan kell programozni C-ben, és ezt valahogy így tudod megoldani, hogy kávzi a struktúra az objektum paramétere, és a get/set függvény a metódusa.

De van egymásik lehetőség is, ami C-seb. Ha függvényekkel dolgozol, akkor amikor átadod a struktúrát, akkor const-ként kell átadni, mert nem akarod, hogy változtatva legyen (pointernél olyat is lehet csinálni, hogy a stuktúra címét ne lehessen változtatni). Így, mivel konstansként akarod használni a függvényen belül, és ne talán tán megváltoztatod az egyik értéket, akkor arra a fordító hibát fog dobni.

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

Kicsit vázolom a helyzetet, hogy most mi van készen.

.h fájl:
typedef struct{
Signal_Types name;
uint16_t id;
uint8_t pos;
uint8_t length;
uint8_t order;
float factor;
float offset;
uint16_t binValue;
float realValue;
}Signal_TypeDef;
Ezek közül a binValue és realValue-n kívül mindegyik csak egyszer kap értéket.

.c fájl:

static Signal_TypeDef SIGNALS[9];
uint8_t CAN_Signal_Init()
{ /*Itt kap értéket a struktúra tömb */}

uint8_t get_Signal(Signal_struct** signal)
{ /*Ezt a függvényt hívják meg a fejlesztők hogy megkapják a signal struktúrát */}

Kéne egy kis segítség a programomban. Ez az egy hiba van már csak benne, de nem jövök rá miért.

Egy telefonkönyves program menüvel a feladat, ez a részlet pedig az egyik függvény, amelyet egy menüből hívok meg.

Igazából az történik, hogyha van elem a listába, akkor az első if ugye nem teljesül, mert lista != NULL pointerrel, azzal nincs is baj. Akkor ugye belép az else ágba. Kiírja szépen az elemeket. Bekéri, hogy melyiket szeretném törölni. Nos itt jön egy feltételvizsgálat ami kiakaszt. Azt nézem meg, hogy számot fog e bekérni, mert ha a scanf függvény egyenlő 0-val(aminek az értékét egy valami változóba tettem be), akkor nem számot írt be a felhasználó, tehát akkor belép a feltételbe.
És most jön a lényeg!! Ugyebár azt kéne csinálnia, hogy kiírja az szöveget és egy karaktert kéne várni a felhasználótól, majd visszatér 0-val. De nem ezt csinálja. Ha nem számot írok be, akkor viszalép egyből a főmenübe, persze felvillan a kiírás, de a getcharok nem állítják meg a programot. Tehát valahonnan kap karaktert a getchar. Ez hogy lehet? Honnan kaphat? Hogy lehetne kijavítani?

Nagyon fontos és sürgős lenne!

Előre is köszi!

A kódrészlet:

Adatok*torol(Adatok*lista)
{
int t=0,valami=0,i;
Adatok*mozgo, *lemarado;
if (lista==NULL){
printf("A lista nem tartalmaz elemeket!\n");
printf ("\nA visszalépéshez kérem nyomjon le egy billentyűt!\n");
getchar();
return 0;
}
else{
listakiiras(lista, 1); // Ez csak kilistázza egy for ciklussal printeffelve a lista elemeit.
printf("\nMelyik bejegyzést szeretnéd törölni?\n");
valami=scanf("%d", &t);
if (valami==0){
getchar();
printf("\nÉrvénytelen válasz.\n\nKérem nyomjon le egy billentyűt a visszalépéshez!\n");
getchar();
return 0;
}
else{ stb. bla bla

Tipp:
getchar elé:
fflush(stfin);

Nekem hasonló problémára ez jelentett megoldást.

A "hatalmas" tapasztalatommal a hülye tanács jogát fenntartanám...

[ Szerkesztve ]

Prodipe Pro 5 aktiv hangfalpar elado.

Köszönöm szépen, ez megoldotta nálam is!

u.i.: Először mikor bemásoltam, néztem is egyet, miért nem fordít, aztán láttam, hogy elírtad

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.

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

Pointert kéne átadnod mindkét függvénynek, nem egy lokális másolatot.

“All nothings are not equal.”

Sziasztok!

Van egy 9 elemű tömböm(a neve legyen tomb), amiben struktúrákat(a typedefelt neve legyen struktura) tárolok ezekben pedig stringet,double-t, int-et(rendre legyenek adat1, adat2, adat3).

Az lenne a kérdésem, hogy hogyan tudnám az adat1-2-3-at különböző függvényeknek úgy átadni, hogy a tömb indexére bevezethessek egy ciklusváltozót és a függvényen beül egy ciklusban az adott műveletet minden tömb struktúrájának adataira elvégezhessem?

Remélem sikerült érthetően megfogalmaznom

Az egyes adatokra ugye úgy tudok hivatkozni, hogy tomb[ciklusvált].adatx, de ezt függvénynek még nem nagyon sikerült úgy átadni, hogy szeresse, és az i-t léptetni is tudjam.

köszi,
SleeD

[ Szerkesztve ]

Ha megoldható, akkor a tömböt add át, és a függvényen belül legyen a .adatx. Ez gondolom menne, tehát valamiért nem megvalósítható.

Alternatívaként csinálhatsz accessor függvényt, varázsolhatsz offsetof segítségével avagy ha esetleg véletlen c++ és nem c akkor member pointerrel.

#include <iostream>
using namespace std;
struct Foo
{
int x;
int y;
};

int sum0_x(Foo* array, int count)
{
int r = 0;
for(int i = 0; i < count; i += 1)
{
r += array[i].x;
}
return r;
}

int sum0_y(Foo* array, int count)
{
int r = 0;
for(int i = 0; i < count; i += 1)
{
r += array[i].y;
}
return r;
}

int sum1(Foo* array, int count, int (*accessor)(Foo*))
{
int r = 0;
for(int i = 0; i < count; i += 1)
{
r += accessor(array + i);
}
return r;
}

int sum2(Foo* array, int count, int member)
{
int r = 0;
for(int i = 0; i < count; i += 1)
{
r += *(int*)((char*)(array + i) + member);
}
return r;
}

int sum3(Foo* array, int count, int (Foo::*member))
{
int r = 0;
for(int i = 0; i < count; i += 1)
{
r += array[i].*member;
}
return r;
}

int accessor_x(Foo* foo)
{
return foo->x;
}

int accessor_y(Foo* foo)
{
return foo->y;
}

int main()
{
Foo foos[2];
foos[0].x = 1;
foos[0].y = 2;
foos[1].x = 3;
foos[1].y = 4;
cout << "sum0(x) = " << sum0_x(foos, 2) << endl;
cout << "sum0(y) = " << sum0_y(foos, 2) << endl;
cout << "sum1(x) = " << sum1(foos, 2, accessor_x) << endl;
cout << "sum1(y) = " << sum1(foos, 2, accessor_y) << endl;
cout << "sum2(x) = " << sum2(foos, 2, offsetof(Foo, x)) << endl;
cout << "sum2(y) = " << sum2(foos, 2, offsetof(Foo, y)) << endl;
cout << "sum3(x) = " << sum3(foos, 2, &Foo::x) << endl;
cout << "sum3(y) = " << sum3(foos, 2, &Foo::y) << endl;
return 0;
}

Jester

Köszi szépen. Délután kipróbálom a dolgot.
MCU-ra írom, egy kommunikációs modul kiegészítése lesz. Azért használok pointert hogy csak egyszer legyen tárolva a struktúra, és azt lehessen átadni. Sajnos ahogy néztem, az egész struktúrát nem tudom átadni, csak egyenként az elemeket. Az lett volna jó ha tudok egy get függvényt írni ami visszaadja a struktúrát és ha valaki a struktúra elemét akarja átírni akkor beszól a fordító, vagy csak egyszerűen nem történik meg a művelet futás közben.

Olyat lehet csinálni, hogy senki nem írhat a struktúrába.

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

typedef struct
{
int ifoo;
char cfoo;
} fooTypeDef;

int get(const fooTypeDef * const foo)
{
int i = sfoo->ifoo; //működnie kellene, ha csak ez van a függvény törzsben
sfoo->cfoo = 'd'; // erre viszont hibát kell, hogy dobjon, mert konstans változóba nem lehet írni
}

int main(void)
{
fooTypeDef sfoo;

sfoo.ifoo = 10;
sfoo.cfoo = 'a';
get(&sfoo);

return 0;
}

Nincs nálam fordító, így nem tudom kirpróbálni, hogy tényleg működik-e.

Fene a jó dolgod. Szívesen foglalkoznék főállásban ilyennel, csak sajnos más fele vitt a sors. Most is körülöttem ilyennel foglalkoznak csak én más projekten vagyok.

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

Ami kimaradt: így a get függvények belül egyik adattagot sem lehet írni, csak és kizárólag olavsni. Az set-get-es függvényeknek azaz előnyük, hogy szabadon lehet változtatni az összes adattagját, viszont get a függvénnyel egyesével tudsz értékeket olvasni. Kivéve ha nem kókányolsz íly módon:

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

typedef struct
{
int ifoo;
char cfoo;
} fooTypeDef;

int get(const fooTypeDef * const foo, int * const ibar, char * const cbar)
{
*ibar = sfoo->ifoo;
*cbar = sfoo->cfoo;
}

int main(void)
{
fooTypeDef sfoo;

sfoo.ifoo = 10;
sfoo.cfoo = 'a';

int ibar;
char cbar;

get(&sfoo, &ibar, &cbar);
printf("%i %c", ibar, cbar);

return 0;
}

Vagy valami ilyesmi lesz.

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

És olyat nem lehet hogy ne a fv visszatérési értéke legyen a változó?

ilyenre gondolok:

valami.c:
fooTypeDef localfoo;

void set(const fooTypeDef * const foo)
{

foo.ifoo=0; //ez csak egyszer hívódik meg

}


void get(const fooTypeDef ** const foo)
{
localfoo.cfoo = a+b; //ez az értékadás minden hívásnál megtörténik
*foo= &localfoo;
}

main.c //ezt hívják majd a fejlesztők

footypedef* myfoo;
get(&myfoo);

myfoo->ifoo = 5; //erre vagy hiba vagy ne hajtódjon végre
myfoo->cfoo = 4; // ez annyira nem nagy hiba mert a legközelebbi hívásnál úgyis felülíródik

egy gyors kérdésem lenne, bináris fájlba íráskor hogyan tudok sort törni?

fprintf(fp,"%s\n",pff); nem működik, neten nem találtam rendes, egyszerű megoldást

What is your ikigai?

Mitől nem működik

Jester

mintha ott se lenne, én sem értem...

kons.txt:

alma
narancs

de a kons.dat-ba csak ezt íja:

almanarancs

a teljes kód így néz ki:

void csinal_dat()
{
char puff[256];
FILE *fpt=fopen("kons.txt","rt");
FILE *fpd=fopen("kons.dat","wb");
if (fpt!=NULL)
{
while(fgets(puff,256,fpt)!=NULL)
{
fprintf(fpd,"%s\n",puff);
}
}
else
printf("hibas megnyitas: kons.txt");

fclose(fpd);
fclose(fpt);
}

[ Szerkesztve ]

What is your ikigai?

Az fgets már eleve rajta hagyja a sorvéget, te meg még plusz teszel is ... ehhez képest ha egy sincs az valami mágia:

$ cat >test.c
#include <stdio.h>

void csinal_dat()
{
char puff[256];
FILE *fpt=fopen("kons.txt","rt");
FILE *fpd=fopen("kons.dat","wb");
if (fpt!=NULL)
{
while(fgets(puff,256,fpt)!=NULL)
{
fprintf(fpd,"%s\n",puff);
}
}
else
printf("hibas megnyitas: kons.txt");

fclose(fpd);
fclose(fpt);
}

int main()
{
csinal_dat();
return 0;
}
$ gcc -g test.c
$ echo -e "alma\nnarancs" > kons.txt
$ cat kons.txt
alma
narancs
$ ./a.out
$ cat kons.dat
alma

narancs

[ Szerkesztve ]

Jester

megvan, notepad nem jelenítette meg csak az entert, beolvasás után jó, köszönöm a segítséget hsz-odból jöttem rá

[ Szerkesztve ]

What is your ikigai?

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!

[ Szerkesztve ]

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.

[ Szerkesztve ]

“All nothings are not equal.”

Ez igaz, ez tényleg nem jó módszer, mert valóban túlindexelheti, persze azt nem tettem hozzá hogy csak ideális esetet nézzünk. Tehát mindenkinek ilyen alakú a neve: Szabó János Tehát is az első szóköz után kell nagybetűsíteni.

Arra gondoltam én is, hogy minden stringet nagybetűsíteni talán könnyebb, de akkor hogyan csinálok kisbetűt belőlük utána ami nem kell?

Az oké, hogy azt a megoldást kell használni 0-tól különböző helyre is, de nem tudom az indexet, hogy hol kéne használni.

Változónak, lehet minimum és maximum értéket adni, és ha lehet akkor hogyan?

"Akinek elég bátorsága és türelme van ahhoz, hogy egész életében a sötétségbe nézzen, elsőként fogja meglátni benne a fény felvillanását." - Kán

max ugy, hogy pl egy fuggveny segitsegevel allitod be az erteket, amiben ellenorzod, hogy a megadott intervallumban van-e az ertek..

int x ;

void setVar(int y) {
if(5<y && y<10)
x=y ;
}

void main() {
setVar(6) ;
}

Tudtommal nem igazán, csak nagyoltan, hogy ha 0 - 255 kell, akkor unsigned char, ha -128 - 127-ig akkor char stb...

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

ha -128 - 127-ig akkor char

Úgy érted, signed char
A sima char típusról nem lehet tudni, hogy előjeles-e, tehát ha neked konkrétan valamelyik változat kell, akkor bizony ki kell írni.

Jester

Köszi, ez nem jó nekem, viszont ebből rájöttem a megoldásra. Szval segített.

"Akinek elég bátorsága és türelme van ahhoz, hogy egész életében a sötétségbe nézzen, elsőként fogja meglátni benne a fény felvillanását." - Kán

Ott van az elején, hogy a "plain char" az lehet "unsigned". A további rész pedig a többi integer típusra vonatkozik, ott van az "other" szócska.

Ja és ez itt szerintem totál témába vág

Jester

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

"Akinek elég bátorsága és türelme van ahhoz, hogy egész életében a sötétségbe nézzen, elsőként fogja meglátni benne a fény felvillanását." - Kán

Mi a kérdés? A kígyó mozgása konkrétan (azaz hogyan tárold a kanyarodásokat), vagy maga a folyamatos léptetés (game loop)?

“All nothings are not equal.”

a folyamatos mozgás (game loop)

"Akinek elég bátorsága és türelme van ahhoz, hogy egész életében a sötétségbe nézzen, elsőként fogja meglátni benne a fény felvillanását." - Kán

Noshát. A game loop nagyon leegyszerűsítve egy végtelen ciklus, ami addig tart, ameddig a játéknak nincs vége. A ciklusmagban pár dolgot kell elvégezned kötötten:

1) Fogadnod kell a felhasználótól a bemenetet. Ez lehet polling jellegű (amikor ideérsz, megnézed milyen gombok vannak lenyomva), vagy eseményalapú, de az előbbi egyszerűbb.
2) Frissítened kell a szereplők állapotát egy lépéssel (folyamatos idejű játéknál egy valamekkora időszelettel). Ehhez felhasználod az előzőleg begyűjtött inputot, meg az esetleges AI döntéseket.
3) Frissíted a világ állapotát, azaz kezeled az ütközéseket, halálokat, születéseket.
4) (legegyszerűbb eset) Újra kell rajzolnod a képernyőt.
5) Be kell aludnod párszáz milliszekundumra.

Ezt kell ismételgetned.
Az SDL, Allegro és társai mind ehhez adnak alapot.

“All nothings are not equal.”

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ítani

signal.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át

Az utolsó sort kellene valahogy megoldanom, hogy ne tudjak a struktúrába módosítani.

const
Persze aki igazán akarja, az úgyis felül tudja írni.

Jester

A válasz meg még mindig az, hogy írj egy
uint16_t signal_get_id(const signal_struct const* signal)
{
return signal->id;
}

függényt a signal.c-be, és a struktúra tagdefinícióját is átrakod oda. A headerben meg csak a forward deklarációk maradnak, így ha a headert használja valaki, nem tudja még a tagok offszetjét ye, ergo nem tudja változtatni.

“All nothings are not equal.”

Sikerült 3 óra ittülés után megcsinálni. Már megvan a setup level is. Ma azt tervezem, hogy a bogyók lerakásával fogok foglalkozni.

"Akinek elég bátorsága és türelme van ahhoz, hogy egész életében a sötétségbe nézzen, elsőként fogja meglátni benne a fény felvillanását." - Kán