Köszi neked is. Fellelkesítettetek, be is izzítottam.

Sziasztok!

Olyat lehet csinálni hogy létrehozok egy struktúrát amiben néhány változónak void típust adok.
Majd ebből a struktúrából létrehozok egy tömböt. És a tömb eleminek adom meg a pontos típust?
pl:

typedef struct{
int ID;
void data;
}myStruct;

myStruct[2] array;
int data = 2;

array.data = (int)data;

}

Nem. union-t használhatsz arra, hogy többféle (de előre ismert) típusnak helyet foglalj.

Jester

Sziasztok!
Egy könyvben talált példa értelmezésében kérnék segítséget:
#include <stdio.h>
#include <stdlib.h>
#define KULCS 0xE7

int main()
{
char s[80], *p;
int i;
printf("Kerek egy szoveget:");
fgets(s,80,stdin);

for(i=0;s[i];i++)
{
s[i]^=KULCS; /*Titkosítás*/
}
printf("A titkositott szoveg:\n %s\n",s);

p=s;
while(*p)
{
*p++^=KULCS; /*Visszaállítás*/
}
printf("Az eredeti szoveg:\n%s\n",s);
return 0;
}

A példából csak azt a részt nem értem, amikor kizáró vagy segítségével titkosítva lesz a szöveg. Azt tudom, hogy mit jelent a kizáró vagy(csak az egyik feltétel teljesülésénél lesz igaz), viszont nem értem, hogy hogyan lehet titkosítani egy hexadecimális szám + kizáró vagy segítségével. (A feladat a pointereket és sztringeket akarja magyarázni, azért van két különböző ciklus használva.)

Probald ki papiron kezzel. Ket szamot felirsz kettes szamrendszerben. Bitenkenti XOR muveletet vegrehajtod rajta. Majd fogod az eredmeny kettes szamrendszerbeli alakjat es XOR muveletet ismet vegrehajtod a ket elozo szam kozul valamelyikkel.

1. szám: 101101, 2. szám: 110110. A művelet végrehajtása után 011011-et kapok. Ha megcsinálom ezt a műveletet az eredménnyel + az 1. számmal, akkor visszakapom a 2. számot.
Akkor ezek szerint, a feladatban az 1. szám a begépelt szöveg, a 2. szám a hexadecimális szám, az eredmény pedig a titkosított szöveg, vagyis a mivel a memóriában a szöveget és a hexadecimális számot(mindent) is 2-es számrendszerben tárolja, ezért amikor végigmegyünk a XOR-al, akkor a két értéket a 2-es számrendszerben hasonlítjuk össze és a visszakapott eredményt(2-es számrendszerbeli számot) újból szövegként írjuk ki?

[ Szerkesztve ]

Nagyjabol igen. Ha van egy kulcsod es egy szamod, amirol tudod, hogy a kulccsal es a XOR muvelettel lett titkositva, akkor a XOR-t vegrehajtva a titkositott szamon visszakapod az eredetit. A fenti feladatod azt hasznalja ki, hogy a C-ben a char integralis tipus, igy a begepelt szoveg minden karakteren tudsz bitmuveleteket vegezni.

[ Szerkesztve ]

Azt, hogy tudom megcsinálni, hogy van egy n elemű szo[20] karaktertömböm, és karaktertömbben lévő betűk ascii kódját áttegyem egy szamok[20] nevű tömbbe?

"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

Nem tudom kipróbálni, de ez lehet, hogy működik:

for(i = 0; i < 20; i++)
{
szam[i] = (int) szo[i]
}

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 egy n elemű szo[20] karaktertömböm"

Most akkor n vagy 20?
Amugy igazan at se kell rakni, hiszen a szo[20]-ban eleve a betuk ascii kodja van benne.

DRM is theft

Az, hogy szo[20] azt mutatja meg, hogy hány karakter fér bele. Az, hogy n elemű pedig, hogy hány elem van benne. Amit strlen-el meg lehet nézni.

"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

Ez lehet jó lesz nekem. És akkor még egy probléma: Hogyan tudok egy stringet tárolni egy másik stringben, ami alatt nem azt értem, hogy több dimenziós karaktertömb. Azt tudom, hogy egy pl egy string[i] helyre max 2 karaktert lehet tenni, de hogy lehetne többet?

"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

"Azt tudom, hogy egy pl egy string(i) helyre max 2 karaktert lehet tenni"

Ezt hogy?... Vagy arra gondolsz, hogy az a string tomb intekbol all es azoknak a kulonbozo byte-jait hasznalod fel?
Igazabol nem ertem az egesz felvetest, hogy mit akarsz csinalni es az miert jo

[ Szerkesztve ]

DRM is theft

Órára kellene nekem egy kódoló program, valami ilyesféle megfeleltetést akarok, hogy szo=a az kodololás után legyen szo(i)=sx. Viszont egy string elem helyére max 2 darab karaktert lehet betenni, és azt sztetném, hogy a szo(i)=a feleljen meg a szo(i)= sx3z-nek.

"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

"egy string elem helyére max 2 darab karaktert lehet betenni,"

Ezt tovabbra sem ertem. Ha az a string[] char tipusu, akkor ott egy elem helyere csak egy karakter fer be. Ha mas a tipusa, akkor meg a konkret tipustol fug, hogy mennyit tudsz oda bezsufolni es mondjuk a logikusan adodo int meg barmilyen modern rendszeren 4 byte-os.

Ha valami olyan kodolast akarsz csinalni, ami fixen egy karakter -> n karakter, akkor a kezdeti char cleartext[20]-at egy char encoded[20*n] tombbe rakd at, semmi ertelme az ilyen trukkozesnek.

DRM is theft

"Error NONAME00.C 13: Character constant must be on or two characters long"

És a progi amire ezt adta így néz ki:

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



void main ()
{
clrscr();
char str[20];
for (i=0;i<strlen(szar);i++)
{
str[i]='asd';
}
getch();
}

[ Szerkesztve ]

"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

Aha, gondoltam, hogy itt valami felreertodott.
Egy char tomb egy helyere csak egy betu fer. Amit te megprobaltal, az a "multicharacter constant", ami igazabol int tipusu, a konkret erteke implementaciotol fugg es eroteljesen ellenjavallott az alkalmazasa (a maximum merete meg szinten implementaciofuggo, van, ahol negy karakterbol is allhat). Ha egyebkent levitted volna ket karakterre, akkor se azt csinalna, amit akarnal, hanem minden bizonnyal a kettobol vagy az egyik vagy a masik karakter kerulne a char tombodbe, nem mind a ketto.

[ Szerkesztve ]

DRM is theft

Értem, és akkor valami megoldás arra, hogy hogyan tároljam le azt, hogy több karaktert taroljak le úgy, hogy az visszavezethető legyen arra az 1 karakterre amiből generáltam azt.

Pl.:

Eredeti szöveg: alma
Kódolt szöveg: 3hrtz5as73hr
Kódolt szöveg felosztása: 3hr | tz5 | as7 | 3hr

"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

Az, amit irtam: a kodolt szoveget haromszor akkora karaktertombben tarolod, mint amekkora az eredeti szoveg volt.

DRM is theft

Értem, csak azt nem tudom, hogy abból hogy kódolom vissza?

"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

Miert, amugy hogy dekodolnad? Na, teljesen ugyanugy Csinalsz valami ilyen fuggvenyt, hogy:
char decode(char x[3])
es ezt hivogatod:
for (c=0; c < length; c++)
{
decoded_str[ c ] = decode( &encoded_str[c*3] );
}

[ Szerkesztve ]

DRM is theft

Például csinálsz egy structot ami a c++ MAP-hez hasonlóan kulcs-érték párt tárol.
A kulcs lesz az eredeti sztring adott karakterének indexe, az érték pedig a hozzá kódolt string.
Így nem muszáj, hogy a kódolt rész-stringek is ugyan olyan sorrendben legyenek a tömben mint az eredeti string karakterei.

struct Crypt
{
int index;
char crypt_text[3]
};

struct Crypt encrypted_text[20];

original_string = a l m a
0 1 2 3

encrypted_text[0]:
---- index=3 (original_string[3] --> a)
---- crypt_text=3hr
encrypted_text[1]:
---- index=0 (original_string[0] --> a)
---- crypt_text=3hr
encrypted_text[2]:
---- index=2 (original_string[2] --> m)
---- crypt_text=as7
encrypted_text[3]:
---- index=1 (original_string[1] --> l)
---- crypt_text=tz5

Megj: Amúgy az nem valami jó titkosító alg. ami két ugyanolyan bemenetre ugyanazt a kimenetet produkálja
a --> 3hr

[ Szerkesztve ]

Ez volt a legjobb ötlete, ugyanis nem szabadott kulcsot használni, és az kapott 5-öst akinek nem lehetett rájönni az algoritmusára.

Délután még megpróbálkozok máshogy is megcsinálni.

"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

De hat ezt kb. ranezesre lehet torni, ennel az is durvabb lenne, ha minden karaktert az elozovel xorolnad.

DRM is theft

Ezt igen, de ez az enyémhez képest egy lebutított rész, ugyanis csak ezt a részt nem tudtam kivitelezni.

"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

Újabb probléma.

Van egy 287528739523985 számsorozat. Ami mindegy milyen számokból áll.

Úgy szeretném bekérni a felhasználotól ezt a számsorozatot, hogy ő folyamatosan írja ezt be, de a program mégis 3 karakterenként értelmezze.
Pl.:
Amit a felhasználó beír:

122345782765783

Amit a program lát:

tomb[0]=122
tomb[1]=345
tomb[2]=782
tomb[3]=765
tomb[4]=783

[ Szerkesztve ]

"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

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*)&num;
.......
}

1 byte-os adatra mutatok egy olyan mutatóval amely a fordító szerint 4 byte-os "blokkokat értelmez"...
Lehet ebből gond?

[ Szerkesztve ]

keress ra arra, hogy struct packing

pl. [link]

ha nagyon szeretnel 1-et latni, akkor:

#pragma pack(1)

Amíg nem akarod átportolni más architektúrára, neadjisten fordítóra a kódot, nagy baj nem lehet. Például az ARM processzorokon felrobbanna a kód, ha nem lenne 32 bitre alignolva.

“All nothings are not equal.”

Ennek speciel semmi köze a packinghoz, sokkal inkább ahhoz, hogy a megadott típus "unsigned" volt. Ha "unsigned char" lett volna, rögtön 1 lett volna a mérete.

Jester

Valóban! Köszönöm

De közben ilyent is találtam, ez is működött:
typedef struct __attribute__ ((packed)) bitfield

Amúgy hogyhogy működik a char?
" The type-specifier for the declarator must be unsigned int, signed int, or int"

Nem lehet, hogy C++ fordítót használsz? Ott bármilyen egész típus szerepelhet a bitfieldben, akár enum is.

“All nothings are not equal.”

gcc-t használok.

Azt hiszem megtaláltam a választ: [link]. Ha a -pedantic paramétert odaadnád neki fordításkor, akkor valószínűleg lenne warning. A C99 szabvány már megengedi a chart is, bár implementáció-specifikus az idézet szerint.

“All nothings are not equal.”

Valóban.
Nem gondoltam, hogy ez így meg van kötve ezért nem is néztem utána.
De most megtettem így még két pont érdekes:

An implementation may allocate any addressable storage unit large enough to hold a bit-field.

Tehát még ha el is fogadja a char-t akkor sem kötelező neki abban tárolni.
Továbbá:

The order of allocation of bit-fields within a unit (high-order to low-order or low-order to high-order) is implementation-defined.

Vagyis a fenti példában a bit0-7 tagok egyáltalán nem biztos, hogy a névből következő helyiértéknek felelnek meg.

Jester

sziasztok, feltelepitettem xp-re a code blocks-ot, de az f9 (futtatás) nem akar müködni. valaki nem tudja mit kell beállitani?

előre is köszi, fontos lenne.

Privát üzenetre illik válaszolni!!!

Dob valami hibakódot?

Melyik setupot telepítetted?

<< Heimdal >>

az elsőt telepitettem xp-re. ezt irja ki:

Probably the toolchain path within the compiler options is not setup correctly?!
Goto "Settings->Compiler and debugger...->Global compiler settings->GNU GCC Compiler->Toolchain executables" and fix the compiler's setup.

a settingsbe a debugger config meg üres...

Privát üzenetre illik válaszolni!!!

A 28 megás nem tartalmaz fordítóprogramot, a harmadikat töltsd le.

<< Heimdal >>

Most már működik, köszi a segítséget...

Privát üzenetre illik válaszolni!!!

Sziasztok! Egy kis segítségre lenne szükségem. Először elmondom a szitut. Már több szemeszter óta vergődök az alap C programozással, nem szeretem, nem áll rá az agyam. Idén már pénzbe is fájt, úgyhogy megpróbálom megemberelni magam, és most igyekszem megérteni, legalább nagyon alapszinten. Úgy ahogy haladok, de persze nevetséges tudásom van, ami nem is baj, csak a zh-n vergődjek át. A következő feladatot kellene (többek közt) megoldanom, tudnátok segíteni?

Töltsön fel egy egész típusú 100 db elemet tartalmazó tömböt páratlan számokkal 100-tól csökkenő értékkel! Adja össze a páros számú indexen levő elemek értékét! Vegye az átlagát a páratlan indexen levő tömb elemeknek!

Megmutatom, mire jutottam: (ja, nem egész típusú a tömböm, ezt elfelejtettem figyelembe venni, ennek lehet valami hátránya? a hsz végén szóba hozom a típuskonverziót, azért, mert sok feladatnál használtunk már double-t, és akkor int-re konvertáltunk, és ez a rutin megmaradt, csak nem teljesen tiszta)

int main()
{
double t[100]; unsigned int i=0, j=100, pl=0, ps=0;
while(i<100)
{
t[i]=j;
if((j%2))
/* {
if((j&0xF1)==0x55)
{
pl=pl+t[i];
}
}*/


printf("%lf\n", t[i]);
i++;
j--;
}
printf("paratlan indexu elemek erteke %d", pl);


return 0;
}

A tömbfeltöltés még sikerült. A program nyilván nincs kész. A gondom az, hogy ha belerakom a kicsillagozott részt, akkor egyrészt nem jó eredményt dob(úgy gondolom, hogy úgy sz*r az, ahogy van), és a tömbfeltöltést is elrontja, mert nem csak a páratlan számok kerülnek be, hanem mind.

A logikám az volt, hogy maszkolni kéne a következő bitsort: x1x1x1x1-et, az 11111111-al, az x-ek helyén mindegy mi van, a páros bitek helyén meg 1-es ugye, mivel az kell, és amelyik j-re ez teljesül, azokat összeadja pl változóba.

Most hogy visszanézem, kicsit belegabalyodtam, szerintem nem is j-t kell vizsgálni, de tényleg nem tudom már hogyan tovább. Ez a maszkolósdi amúgy se megy, illetve szerintem egy típuskonverzió is kéne valahova, de ahhoz sem értek.

Valaki tud életet menteni? Előre is köszönök minden segítséget

[ Szerkesztve ]

"The time you enjoy wasting is not wasted time."

100-tól csökkenve 100 db páratlan szám csak úgy van, ha negatív számokat is veszünk, vagy ha egy páratlan számot többször is értékül adunk. Van valami pontosítás a feladattal kapcsolatban ezen a téren?
Mert ha nincs akkor én úgy csinálnám hogy 99-től visszafelé indítok egy ciklust (for), úgy hogy kettesével lépked visszafelé. Tárolnám a számot az aktuális és az aktuális+1 indexű elemben.
Ezzel kész is a feltöltés csökkenő sorrendben.
Ezután egy újabb ciklusban feldolgoznám a tömböt. A ciklus végigmegy a tömbön és összeadogatom két változóban az elemeket. Egyikben a páros indexűeket, másikban a páratlan indexűeket. (Vedd észre, hogy mivel két egyforma elem követi egymást, ezért az összeg pontosan ugyan annyi lesz a végén mindkét változóban, mivel a tömb valahogy így néz ki: 99,99,97,97,95,95...1,1)
Ezután kiírom a páros indexűek összegét, majd a páratlan indexűek összegét elosztom 50-el és azt írom ki (ez lesz az átlag).

Ne erőltesd bele egy ciklusba az egészet (persze úgy is meg lehet csinálni).

Számomra a kérdés a tömb feltöltésének pontos szabálya.

[ Szerkesztve ]

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

Köszönöm, közben sikerült megoldani!

"The time you enjoy wasting is not wasted time."

Kicsit rég volt de azért leírom
Remélem azóta már rájöttél, hogy ez a kód nem működik helyesen, logikailag hibás.
Nézd meg pl ezekkel a dátumokkal:
2014-05-02
2013-04-06
2013-04-04

A 2.kat hozza ki a legkorábbi dátumnak.

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?

Írd úgy meg az összehasonlító függvényt, hogy egyező elemeknél vegye figyelembe az eredeti indexet. Legkevesebb meló ha kiegészíted az elemeket az indexszel. Persze cserébe ez nem a leghatékonyabb.

Jester

A C standard qsort függvény tényleg nem stabil, azaz átrendezheti az egyenlő elemeket.

Viszont nem kell n!-szor végigjárnod a tömböt (ez még a legegyszerűbb beszúrásos rendezésnél is rosszabb gondolat, ami csak n^2-es lépésszámú).

Nézz szét a rendezési algoritmusok között, keress egyet ami tetszik és stabil, és implementált. Javaslom az összefésüléses rendezést, ahogy a wiki is említi, a C++ STL-ben ez érhető el stable_sort néven.

(De ha kicsit keresgélsz, találhatsz implementációt készen is. Nem teszteltem.)

“All nothings are not equal.”

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?