[C]hulp nodig met een c-programma

[XeRiOn]

Ik heb dus een opdracht gekregen om een c-programma te ontwerpen met declaratietabel en een PSD. Maar aangezien ik nog zeer weinig met dit programma heb gewerkt kom ik hier niet helemaal uit. Dus misschien kunnen jullie me hier een beetje bij helpen.

De opdracht luid als volgt:

Met de opdracht 'ontwerp' wordt steeds bedoeld:
- maak vooraf een declaratietabel en een PSD per functie
- schrijfhet C-programma in de afgesproken stijl in ANSI
- voorzie het programma van functioneel commentaar
- De te ontwerpen functies moeten minimaal aan de opgegeven specificaties voldoen.
- Het is NIET toegestaan de standaard stringfuncties uit de C-bibliotheek te gebruiken.
- Kies voor elke variabele de kleinst mogelijke scope! (dus geen globale variabelen)

Opdracht:
Ontwerp een C-programma dat twee regels tekst kan inlezen en bepaalt of deze regels gelijk of ongelijk zijn aan elkaar. Op het beeldscherm wordt afgedrukt of de zinnen wel of Diet aan elkaar gelijk zijn.

randvoorwaarden:
- het inlezen van de regels gebeurt in ma in () aanwijzing: gebruik gets ( )
- voor het bepalen of de zinnen gelijk zijn wordt een aparte functie gemaakt
- het melden van het resultaat (gelijk of niet gelijk) gebeurt in main ()

Eindproducten:
Programma structuurdiagram en declaratietabel van elke functie.
Het complete ANSI-C programma op papier en op diskette (of per e-mail).

Het is volgens mij een simpele opdracht als je met al veel met dit programma hebt gewerkt, maar ik kom er niet helemaal uit.

[D2k]

wat dacht je van de faq lezen mbt huiswerk?
en als je er niet uitkomt heb je vast wel wat geprobeerd?
deel het met ons of gaat henen

[Verwijderd]

"er niet uit" waar niet uit? iets specifieker graag

[ACM]

XeRiOn schreef op 28 augustus 2002 @ 13:15:
Maar aangezien ik nog zeer weinig met dit programma heb gewerkt kom ik hier niet helemaal uit.

Lijkt me logisch, als je het nog niet gemaakt hebt

Het is volgens mij een simpele opdracht als je met al veel met dit programma hebt gewerkt, maar ik kom er niet helemaal uit.

Het lijkt mij ook een simpele opdracht.
Begin bij het begin (zorg ervoor dat je een C-applicatie maakt die 1 string inleest) en breid dat langzaam uit.

Vertel ook waar je niet uitkomt en wat je al gedaan hebt, want het is, zoals je zelf al zegt, een simpele opgave en volgens mij is er kwa hulp niet veel meer mogelijk dan (zoals je de vraag nu stelt) heel globaal of gewoon de programma code.

Btw, het is C en niet C++... Daar zit nogal een verschil in.

[.oisyn]

XeRiOn schreef op 28 augustus 2002 @ 13:15:
aanwijzing: gebruik gets ( )

lekkere aanwijzingen geven ze bij jullie op school

[D2k]

.oisyn schreef op 28 augustus 2002 @ 14:45:
[nohtml]
[...]
[/nohtml]

lekkere aanwijzingen geven ze bij jullie op school

idd
http://www.rt.com/man/getc.3.html

BUGS
Because it is impossible to tell without knowing the data
in advance how many characters gets() will read, and
because gets() will continue to store characters past the
end of the buffer, it is extremely dangerous to use. It
has been used to break computer security. Use fgets()
instead.

[XeRiOn]

ik heb dus dit al:


#include <string.h>
#include <stdio.h>
int i;
int main(int argc, char **argv)
{
char woord1[128];/* eerste woord dat ingelezen wordt */
char woord2[128];/* tweede woord dat ingelezen wordt */

/****** regels inlezen *****/
printf("typ het eerste woord in voor de vergelijking\n");
scanf("%s", &woord1);

printf("typ het tweede woord in voor de vergelijking\n");
scanf("%s", &woord2);

printf("\nwoorden die ingetypt zijn:\n");
printf("%s\n", woord1);
printf("%s\n", woord2);

/****** woorden vergelijken ******/
i = strcmp(woord1, woord2);
if (i == 0) printf("\nWoorden zijn gelijk!\n");
else printf("\nWoorden zijn niet gelijk!\n");

/****** klaar!!! ******/
printf("druk op een toets om programma af te sluiten.\n");
while (!kbhit()){}

return 0;
}


maar i.pv. het vergelijken van 2 woorden moet ik dus 2 regels tekst vergelijken.
Daar kom ik dus nog niet helemaal uit.

[.oisyn]

je moest ook gets () gebruiken
bovendien stond dit ook nog in de omschrijving:

Het is NIET toegestaan de standaard stringfuncties uit de C-bibliotheek te gebruiken

strcmp () mag dus niet

[Verwijderd]

probeer dit eens:

code:

#include <string.h>
#include <stdio.h>
#include <iostream.h>

void main() {
    //inlezen zinnen
    char zin1[150],zin2[150];
    cout << "Geef zin 1: " <<  endl;
    cin.get(zin1);
    cout << "Geef zin 2: " << endl;
    cin.get(zin2);
    
    //vergelijken
    for (int i=0,i<151,i++) {
        if (zin1[i]!=zin2[i]) then
           clrscr();
           cout << "Zinnen niet gelijk!"<<endl;
           exit(1);
    }
    clrscr()
    cout << "zinnen zijn gelijk!!!" << endl;

}

er kunnen nog wat foutjes inzitten want dit is gewoon uit het blote bolletje, ik kan nu ook niet kijken want ik zit nog op mijn werk.

Succes

[Creepy]

Logik2001: Eehhh.. er staat dat hij gebruik moet maken van ANSI C.. niet C++... scheelt nogal he. Al dat cout << en cin. zal niet kunnen dus.

Ook KAN je strings NIET vergelijken met == of != aangezien je dan de POINTERS naar de karakters gaat vergelijken, en deze zullen (als het goed is) NOOIT gelijk zijn.

Oh.. en wat leert iemand van domweg code overtypen??? Ik dacht dat het niet helemaal de bedoeling was om iemand kant en klare code te geven (ook al is deze uit het hoofd en ongetest), en zeker niet met huiswerk. Tips geven, en stukjes code zijn een stuk leerzamer aangezien het allemaal nog aan elkaar gehangen moet worden, en hiermee dwing je iemand er mee te werken, en dus te leren.

[Verwijderd]

Oh, niet goed gekeken. Ik het kunnen veranderen naar ansi C maar je hebt gelijk hij leert er dan eigenlijk niks van.

w8 hier heb je meer aan: http://www.howstuffworks.com/c.htm
of deze http://members.tripod.com/~johnt/c.html

p.s. die for loop kun je wel gebruiken in ansi C om te controleren.

Succes

[XeRiOn]

hier heb ik wel wat aan, iig al bedankt voor jullie reacties

[Verwijderd]

XeRiOn schreef op 28 augustus 2002 @ 15:28:
#include <string.h>
/* Deze lib mag je volgens de opgave niet gebruiken: -1 punt */

#include <stdio.h>
int i;
/* Dit is een globale variabele en dat mocht niet volgens de opgave: -1 punt */

int main(int argc, char **argv)
{
char woord1[128];/* eerste woord dat ingelezen wordt */
char woord2[128];/* tweede woord dat ingelezen wordt */

/****** regels inlezen *****/
printf("typ het eerste woord in voor de vergelijking\n");
/* Er is niet gevraagd om prompting: -1 punt */

scanf("%s", &woord1);
/* De opgave velangt het gebruik van gets(): -1 punt */

printf("typ het tweede woord in voor de vergelijking\n");
scanf("%s", &woord2);

printf("\nwoorden die ingetypt zijn:\n");
/* Ook deze output wordt niet verlangd: -1 punt */

printf("%s\n", woord1);
printf("%s\n", woord2);

/****** woorden vergelijken ******/
i = strcmp(woord1, woord2);
/* Dit mag niet, de opgave was een eigen functie te schrijven die strings vergelijkt: -1 punt */

if (i == 0) printf("\nWoorden zijn gelijk!\n");
else printf("\nWoorden zijn niet gelijk!\n");

/****** klaar!!! ******/
printf("druk op een toets om programma af te sluiten.\n");
while (!kbhit()){}
/* Microsoft zult die maakt dat je programma niet meer portable is en niet in batch-mode gedraaid kan worden: -1 punt */

return 0;
}

Maw. je kunt blij zijn dat ik je leraar niet ben, want dan kreeg je een dikke onvoldoende met in rood de opmerking leer de opgave te lezen voor je begint.

[ Voor 0% gewijzigd door Verwijderd op 28-08-2002 16:51 . Reden: typo ]

[Verwijderd]

Verwijderd schreef op 28 augustus 2002 @ 16:14:
...
er kunnen nog wat foutjes inzitten ...

Dat lijkt me wel ja. Ga jij 150 keer twee pointers zitten vergelijken?

[nero355]

Ehh.....net zoiets als een palindroom neem ik aan??
Heb dit wel ergens...maaaar waar................:?
Nou ja, zou het helpen als het erop lijkt contact ik wel wat mensen!!:)

[Verwijderd]

Verwijderd schreef op 28 augustus 2002 @ 16:51:
[...]


Dat lijkt me wel ja. Ga jij 150 keer twee pointers zitten vergelijken?

Daar is C op zich snel genoeg voor, en trouwens heb je nix beters te doen dan mensen afzeiken?

[Verwijderd]

Verwijderd schreef op 28 augustus 2002 @ 17:02:
[...]


Daar is C op zich snel genoeg voor, en trouwens heb je nix beters te doen dan mensen afzeiken?

Ik heb ook niet gezegd dat C (of C++, want zodra je cout en cin gebruikt hebben we het daarover) daar niet snel genoeg voor is, maar het zou nog sneller zijn als je niet 150 keer hetzelfde deed...

[Verwijderd]

kun jij zelf dan een functie schrijven (dus geen strcmp of iets dergelijks gebruiken) wat in 1 keer de hele string vergelijkt met een andere string. En dus ook geen for (int i=0,i<strlen(zin1),i++) helemaal geen standaard string functies, er zal altijd een pointer zijn wat 1 voor 1 de karakters naloopt...

[nero355]

Nou is het zo??

[Verwijderd]

nero355 schreef op 28 augustus 2002 @ 17:20:
Nou is het zo??

Ja, en zeker bij ansi C want in principe is char zin[20] geen string, je zegt wel string maar je maakt eigenlijk gewoon een array van chars en die zul je toch met een pointer moeten doorlopen, of je ze nou telt, vergelijkt of weet ik wat...

ik weet niet of dit voor alle talen geldt maar zo heb ik het op school geleerd...

[.oisyn]

OPGEPAST!!!

React zet [ i ] tags om naar html code om de tekst schuin te maken, ook in de code tags!

De code van logik2001 is dan ook gewoon:

code:

    for (int i=0,i<151,i++) {
        if (zin1[ i ]!=zin2[ i ]) then
           clrscr();
           cout << "Zinnen niet gelijk!"<<endl;
           exit(1);
    }

(let op die [ i ] achter zin1 en zin2)


dit is trouwens al de 3e keer dat ik zoiets irritants tegen kom... zal het eens in een sticky zetten, totdat die bug verholpen is

.edit: ziezo: Voor iedereen die code in z'n post plaatst!

[Verwijderd]

Ik verwacht nog steeds commentaar op die compare van logik2001 (en dan niet op de syntax van de for-instructie).

edit:

hint:
char zin1[150] = { 'S', 't', 'r', 'i', 'n', 'g', '\0', '\0' };
char zin2[150] = { 'S', 't', 'r', 'i', 'n', 'g', '\0', '\1' };

offtopic:
Ik heb die bug al gemeld en hij is "fixed" volgens chem. Het is erg handig van de react-bouwers om de users te vragen bugs te melden, maar vervolgens niet de nieuwe code up te loaden als de bug gefixed is of iig. een overzicht van de gefixte bugs te publiceren. Op deze manier krijg je dus irritaties bij zowel de users als de programmeurs; ik meld iig. geen bug meer om vervolgens afgezeken te worden...

[curry684]

Creepy schreef op 28 augustus 2002 @ 16:18:
Ook KAN je strings NIET vergelijken met == of != aangezien je dan de POINTERS naar de karakters gaat vergelijken, en deze zullen (als het goed is) NOOIT gelijk zijn.

Tenzij je een luxe hashed-indexed-string class hebt geschreven, daarbij is gelijkheid van de pointer de garantie op gelijkheid van de string.

[.oisyn]

Verwijderd schreef op 28 augustus 2002 @ 18:34:
Ik verwacht nog steeds commentaar op die compare van logik2001 (en dan niet op de syntax van de for-instructie).

offtopic:
Ik heb die bug al gemeld en hij is "fixed" volgens chem. Het is erg handig van de react-bouwers om de users te vragen bugs te melden, maar vervolgens niet de nieuwe code up te loaden als de bug gefixed is of iig. een overzicht van de gefixte bugs te publiceren. Op deze manier krijg je dus irritaties bij zowel de users als de programmeurs; ik meldt iig. geen bug meer om vervolgens afgezeken te worden...

die bug is dus voor geen meter fixed, aangezien de [ i ] gewoon bij zijn compare achter zin1 en zin2 staat

.edit: ja tss snel je post editten he

[Verwijderd]

.oisyn schreef op 28 augustus 2002 @ 18:43:
die bug is dus voor geen meter fixed, aangezien de [ i ] gewoon bij zijn compare achter zin1 en zin2 staat

.edit: ja tss snel je post editten he

Dit was wel een kanjer van een typo, en ik wilde nog een hintje geven

Overigens was mijn eerste reactie op die "fix" exact die van jou

[Sjaaky]

Afgezien van het probleem dat mietje al aangeeft, zit er een "off-by-one" error in.
Een char zin[150] loop je door van 0 tot en met 149 (dus tot 150).
In code:

code:

char zin[150];
for (int i = 0; i < 150; i++) { 
  doeIetsMet( zin[ i ] );
}

[Ericston]

Daarnaast gaat ie hardstikke over bounds als beide strings minder dan 150 tekens zijn...

...de kans dat de vergelijking dan true returned is ongeveer gelijk aan de kans dat 150 achtereenvolgende bytes op een willekeurige locatie in het geheugen gelijk zijn aan een andere rij van 150 bytes op een andere plaats.

Oplossingen zijn een for met een if-break of een while met wat rondslingerende variabelen.

Denk trouwens ook aan verschillende string lengte:

code:

zin1[] = { 'b', 'l', '\0' };
zin2[] = { 'b', '\0' };

[ Voor 0% gewijzigd door Ericston op 28-08-2002 21:46 . Reden: uitbreiding + verbetering + true!=false ]

[Verwijderd]

Nu heb je het verklapt Ericston

Het ding gaat altijd out of bounds, alleen als beide strings 149 tekens (+ '\0') lang zijn niet, maar dan komt die off by one in actie, die ook dan over de '\0' heen vergelijkt.

Maw, dit is niet veel beter dan deze implementatie van strcmp:

code:

int strcmp(const char *str1, const char *str2) {
   return rand() - (RAND_MAX / 2);
}

[Ericston]

Nu heb je het verklapt Ericston

Alleen dankzij je hint.

[XeRiOn]

Verwijderd schreef op 28 augustus 2002 @ 16:50:
[...]


Maw. je kunt blij zijn dat ik je leraar niet ben, want dan kreeg je een dikke onvoldoende met in rood de opmerking leer de opgave te lezen voor je begint.

Ik heb deze opdracht toch ook nog niet ingeleverd.

En je bent inderdaad gelukkig m'n leraar niet, want hij zou het niet echt op rijs stellen dat ik die opdracht hier post

[Verwijderd]

Oke... dat was heel snel gemaakt want ik zat op m'n werk. Hier is wat beters:

code:

#include <string.h>
#include <stdio.h>

int MystrLen(char);
int MystrCmp(int,int,char,char,int);

void main() {
     char zin1[150],zin2[150];
     int Lzin1,Lzin2,jn;
     printf("Geef de eerste zin: \n");
     gets(zin1);
     printf("Geef de tweede zin: \n");
     gets(zin2);
     MystrLen(zin1,Lzin1);
     MystrLen(zin2,Lzin2);
     MystrCmp(Lzin1,Lzin2,zin1,zin2,jn);
     printf("De zinnen zijn ");
     if (jn==0) printf("niet ");
     if (jn==1) printf("wel ");
     printf("gelijk! \n");  
}

int MystrLen (char zinF[150],int t) {
     char ck;
     ck=" ";
     t=0;
     do {
         ck=zinF[t]
         t++;
     while (ck!="\0")
     return t;
}   

int MystrCmp(int l1, int l2, char zinC1[150], char zinC2[150],int jnC) {
     char c1,c2; 
     if (l1!= l2) jnC=0;
     if ((jnC==1) {
       for (int k=0,k<l1,k++) {
            c1=zinC1[t];
            c2=zinC2[t];
            if (c1!=c2) {
               jnC=0;
               break;
            }
     return jnC;    
}

volgens mij is dit beter (er kan nog wel een fout inzitten want ik ben te lui om iets op te zoeken en dus is het weer uit het hoofd alleen iets meer doordacht) en meer volgens de opdracht...

[Sjaaky]

Tja dit gaat nog fout ivm het passen van de parameter/returnwaarde jn/jnC.
Verder is het niet nodig om eerst de lengte van de strings te bepalen. Tijdens het vergelijken kan je ook meteen op '\0' controleren.

[.oisyn]

logik2001: sorry, maar het lijkt weer helemaal nergens op
niet lullig bedoeld hoor, maar zou het niet handig zijn dat als je er weinig verstand van hebt (wat blijkt uit jouw post), je ook gewoon niet probeert om oplossingen te posten? Je helpt hier de topicstarter namelijk totaal niet mee (nou ja, je geeft iig aan hoe het niet moet )

[Soultaker]

Misschien ben ik dat gewoon, maar als je handig was geweest, had je gewoon even de libc code uit een willekeurig open source operating system gepakt. Natuurlijk absoluut niet de bedoeling, maar wel een aanwijzing dat je enigszins hebt nagedacht over waar je mee bezig bent. Dat is nu zeker niet het geval.

Heb je niet toevallig een boek bij dit vak wat je door had moeten lezen ofzo?

<sub>Ik heb het even geprobeerd en je kunt een ISO-compatible strcmp implementatie schrijven in slechts 40 karakters, inclusief whitespace!

int strcmp(const char *a, const char *b)
{
/* jouw 40 karakters hier! */
}

edit: In 40 karakters is 'ie niet ISO-compatible. Er moeten nog twee unsigned char casts in, dat kost weer 30 extra karakters.</sub>

[Verwijderd]

XeRiOn schreef op 28 augustus 2002 @ 21:34:
Ik heb deze opdracht toch ook nog niet ingeleverd.

Erger nog, je hebt hem niet eens goed gelezen. Een van de grootste problemen die mensen tegenkomen als ze leren programmeren (en dat kan jaren duren) is dat ze te vroeg beginnen met code te kloppen.

De opdracht gaat uit van een PSD, en normaal maak je dat voordat je begint je code in te tikken (je baseert er immers je code op als het goed is), en nadat je het probleem begrepen hebt. Heb je een PSD gemaakt, of heb je gewoon MSVC gestart en bent begonnen met "klooien", nog voordat je de opdracht helemaal gelezen had?

[johnwoo]

Soultaker schreef op 28 augustus 2002 @ 23:03:
Misschien ben ik dat gewoon, maar als je handig was geweest, had je gewoon even de libc code uit een willekeurig open source operating system gepakt. Natuurlijk absoluut niet de bedoeling, maar wel een aanwijzing dat je enigszins hebt nagedacht over waar je mee bezig bent. Dat is nu zeker niet het geval.

Heb je niet toevallig een boek bij dit vak wat je door had moeten lezen ofzo?

<sub>Ik heb het even geprobeerd en je kunt een ISO-compatible strcmp implementatie schrijven in slechts 40 karakters, inclusief whitespace!

int strcmp(const char *a, const char *b)
{
/* jouw 40 karakters hier! */
}

edit: In 40 karakters is 'ie niet ISO-compatible. Er moeten nog twee unsigned char casts in, dat kost weer 30 extra karakters.</sub>

Wedstrijdje compact coden
In 40 karakters: (nergens in opgezocht btw)

code:

int mystrcmp(const char* a, const char* b) {
    // Compare two strings.
    // Return 0 if not equal, nonzero if equal.
    while(*a&&*a==*b){a++;b++;}return*a==*b;
}

Moet ik wel toegeven dat deze niet -1, 0 of 1 teruggeeft zoals de std strcmp, maar gewoon nonzero voor gelijke strings en 0 voor ongelijke strings.

[ Voor 0% gewijzigd door johnwoo op 28-08-2002 23:29 . Reden: haakjes rond de return expressie konden weg :P ]

[Verwijderd]

johnwoo schreef op 28 augustus 2002 @ 23:24:
Moet ik wel toegeven dat deze niet -1, 0 of 1 teruggeeft zoals de std strcmp, maar gewoon nonzero voor gelijke strings en 0 voor ongelijke strings.

Verander het dan in return *a-*b; dan klopt het wel en is nog een karakter korter

edit:
Dit gaat er wel van uit dat char == unsigned char

[Sjaaky]

In 46 karakters: ...

Ik vraag me af wat de leraar van XeRiOn daar van gaat zeggen...

Ik zat op 71 karakters, maar dan is het voor beginners ook nog te snappen.

[Soultaker]

In 40 karakters had ik 'm zo bedacht:

code:

while(*a&&*a==*b){++a;++b;}return *a-*b;

De controle op "*b" is overbodig; immers als *b == '\0' dan geldt (*a == *b) == 0 (aangezien *a != '\0', dat wordt daarvoor al gechecked). Verder is het minteken 1 karakter korter dan de == en heeft tot gevolg dat het resultaat, conform de ISO specificatie, kleiner dan 0 / gelijk aan 0 / groter dan 0 is als string a kleiner dan / gelijk aan / groter dan string b is.

Hij kan trouwens nog 1 karakter korter: (39 karakters)

code:

while(*a&&*a==*b&&++a)++b;return *a-*b;

Veel compacter dan dit wordt 't niet, denk ik, maar misschien valt er nog een karakter of twee te beknibbelen.

Qua ISO compliance gaat 't trouwens mis op 't feit dat de characters als unsigned characters vergeleken moeten worden. Daarvoor moeten *a en *b in de return value dus gecast worden naar unsigned char (wat VEEL karakters kost) of de functie definitie moet aangepast worden (maar dat lijkt me niet wenselijk in verband met compiler warnings hoewel het feitelijk wel zou werken).

[Verwijderd]

Damn, weer te laat met editen

[johnwoo]

Verwijderd schreef op 28 augustus 2002 @ 23:30:
[...]


Verander het dan in return *a-*b; dan klopt het wel en is nog een karakter korter

edit:
Dit gaat er wel van uit dat char == unsigned char

Damn ja, waarom heb ik dat nou niet gezien
Maar hij geeft dan nog steeds geen -1 / +1 terug bij ongelijke strings, maar gewoon een negatief dan wel positief getal (het verschil in ASCII waardes van het eerste ongelijke teken).

Ik heb nu dus 39 karakters:

code:

int mystrcmp(const char* a, const char* b) {
    while(*a&&*a==*b){a++;b++;}return*a-*b;
}

[edit] Hmm... topic gaat ff snel
Bovenstaande code geeft trouwens geen warnings, zelfs niet op hoogste warning level

... en het is eigenlijk ook vrijwel hetzelfde als wat jij hebt
Die for loop hieronder is wel slim

[Sjaaky]

for(;*a&&*a==*b;a++,b++);return *a-*b;
weer een karakter minder.

_{edit:
Er is eigenlijk al veel te veel gereplied, maar toch nog even in 34 karakters:
for(;*a&&*a++==*b++;);return*a-*b;}

[Soultaker]

Sjaaky schreef op 28 augustus 2002 @ 23:37:

code:

for(;*a&&*a==*b;a++,b++);return *a-*b;

Die spatie na de return blijkt er af te mogen (had ik ook nog niet gedaan, trouwens); dan is 'ie 37 karakters.

[ Voor 0% gewijzigd door Soultaker op 28-08-2002 23:43 . Reden: stomme React spacing fixen ]

[Verwijderd]

johnwoo schreef op 28 augustus 2002 @ 23:37:
Damn ja, waarom heb ik dat nou niet gezien
Maar hij geeft dan nog steeds geen -1 / +1 terug bij ongelijke strings, maar gewoon een negatief dan wel positief getal (het verschil in ASCII waardes van het eerste ongelijke teken).

Dat hoeft ook niet volgens ISO 9899:

RETURN VALUE
The strcmp() and strncmp() functions return an integer
less than, equal to, or greater than zero if s1 (or the
first n bytes thereof) is found, respectively, to be less
than, to match, or be greater than s2.

[klinz]

johnwoo schreef op 28 augustus 2002 @ 23:37:
[...]


Damn ja, waarom heb ik dat nou niet gezien
Maar hij geeft dan nog steeds geen -1 / +1 terug bij ongelijke strings, maar gewoon een negatief dan wel positief getal (het verschil in ASCII waardes van het eerste ongelijke teken).

Laat dat nou net volgens de ISO specs zijn...

[johnwoo]

Mja idd.. geen idee hoe ik ineens bij die -1/0/+1 kom

Nog ff wat korter:

code:

int mystrcmp(const char* a, const char* b) {
    w(*a&&*a==*b){a++;b++;}r*a-*b;
}

_{Moet je er wel ff enkele #define's boven zetten...}

[Soultaker]

johnwoo schreef op 28 augustus 2002 @ 23:47:
_{Moet je er wel ff enkele #define's boven zetten...}

Die mag je dan ook meetellen.

[Sjaaky]

hmm dacht ik slim te zijn met een for maar

code:

for(;*a&&*a++==*b++;);return*a-*b;
while(*a&&*a++==*b++);return*a-*b;

zijn weer precies even lang (34 karakters).

[XeRiOn]

mietje, je lijkt m'n leraar wel

[johnwoo]

for(;*a&&*a++==*b++;);return*a-*b; werkt niet; als ik bijvoorbeeld "abcd" met "abce" vergelijk geeft ie nog steeds 0 terug... Kan wellicht aan compiler implementatie van de post-increment liggen, maar op MSVC doet ie t niet goed iig.

[edit]
Yups, while(*a&&*a++==*b++);return*a-*b; heeft hetzelfde probleem. De increments toch maar in de body van de loop...

[Soultaker]

Als het alleen om gelijkheid (return value zero) of ongelijkheid (return value non-zero) gaat, kan 'ie zo ook nog:

code:

return*a?*a-*b?1:strcmp(a+1,b+1):*b;

Goed voor 36 karakters.

[Soultaker]

johnwoo schreef op 28 augustus 2002 @ 23:57:
for(;*a&&*a++==*b++;);return*a-*b; werkt niet;

Terecht; stop er maar eens "ab" en "bb" in. De tweede test faalt, maar de pointers worden wel opgehoogd, waardoor a en b beiden naar 'b' wijzen wanneer het resultaat wordt berekend.

Geloof me, ik heb hier ook aan gedacht.

[Sjaaky]

hmm shit. Ik dacht het getest te hebben.

[Soultaker]

Sjaaky schreef op 29 augustus 2002 @ 00:02:
hmm shit. Ik dacht het getest te hebben.

Je moet ook niet testen, je moet de correctheid bewijzen!

_{Ik geef trouwens geen garanties op mijn eigen code. Schiet maar lek dus.}

Ik denk trouwens dat we topic starter goed op weg geholpen hebben zo!

[johnwoo]

Die recursieve van Soultaker kan natuurlijk korter door de functie een naam van 1 karakter te geven

Kortste tot nu toe:

Iteratief: 39 karakters
for(;*a&&*a==*b;){a++;b++;}return*a-*b;
Recursief: 31 karakters
return*a?*a-*b?1:f(a+1,b+1):*b;

De iteratieve zal trouwens wel een stuk efficienter zijn denk ik, t scheelt behoorlijk wat function call overhead.

En topicstarter heeft het nu inderdaad voor het kiezen

[Soultaker]

Ik vind dat je niet buiten de body van de functie mag werken, dus de recursieve variant hernoemen is valsspelen. Daarbij is de vraag in hoeverre 'ie aan een strcmp implementatie voldoet, aangezien hij geen groter-dan/kleiner-dan waarde retourneerd maar alleen ongelijkheid.

Aan de ISO-norm voldoen geen van de genoemde oplossingen, als ik 't goed heb, vanwege het gedoe met unsigned comparison.

[Sjaaky]

Tja die recursie is wel slim.
Als de test niet werkt ga niet eens beginnen met bewijzen

[Sjaaky]

Hoe test je dan op de ISO-norm?
Als je het met "gcc -ansi -pedantic -Wall strcmptest.c" foutloos kan compileren _{(want dat doet het)}, is het dan nog niet goed genoeg?

[johnwoo]

Sjaaky schreef op 29 augustus 2002 @ 00:12:
Hoe test je dan op de ISO-norm?
Als je het met "gcc -ansi -pedantic -Wall strcmptest.c" foutloos kan compileren _{(want dat doet het)}, is het dan nog niet goed genoeg?

Op MSVC compilet het ook zonder warnings op level 4...

[Soultaker]

Het gaat om dit deel van de specificatie:

The sign of a non-zero return value shall be determined by the sign of the difference between the values of the first pair of bytes (both interpreted as type unsigned char) that differ in the strings being compared.

Dat betekent dat '\200' - '\2' een positieve return value moet opleveren. Aangezien '\200' een char is, is de waarde al negatief en door er 2 twee van te trekken, wordt het resultaat alleen maar negatiever. Eigenlijk moeten de twee waarden dus naar unsigned char gecast worden, maar dat is zoveel werk, dat onze code size gelijk verdubbelt.

[.oisyn]

Sjaaky schreef op 29 augustus 2002 @ 00:12:
Hoe test je dan op de ISO-norm?
Als je het met "gcc -ansi -pedantic -Wall strcmptest.c" foutloos kan compileren _{(want dat doet het)}, is het dan nog niet goed genoeg?

dat het compilet wil nog niet zeggen dat je aan de normel voldoet qua functionaliteit van de functies

ik kan ook wel dit schrijven:

code:

int strcmp (const char *, const char *)
{
    return 1;
}

het zal foutloos compilen met alle warnings aan, maar verder klopt er geen zak van

[Verwijderd]

johnwoo schreef op 28 augustus 2002 @ 23:57:
for(;*a&&*a++==*b++;);return*a-*b; werkt niet; als ik bijvoorbeeld "abcd" met "abce" vergelijk geeft ie nog steeds 0 terug... Kan wellicht aan compiler implementatie van de post-increment liggen, maar op MSVC doet ie t niet goed iig.

[edit]
Yups, while(*a&&*a++==*b++);return*a-*b; heeft hetzelfde probleem. De increments toch maar in de body van de loop...

Klopt, dit heeft niks met de compiler te maken, op deze manier is de return gewoon fout: je trekt niet de laatste twee chars van elkaar af, maar de chars daarna. Maw. dit gaat weer out of bounds, of (zoals in dit geval) returnt het '\0' - '\0' wanneer beide strings even lang zijn en alleen in het laatste char verschillen.

[ Voor 0% gewijzigd door Verwijderd op 29-08-2002 02:57 . Reden: naar ik nu zie heb ik alle post sinds 0:00 gemist? dit is overbodig ]

[curry684]

.oisyn schreef op 29 augustus 2002 @ 00:19:

[...]

code:

int strcmp (const char *, const char *)
{
    return 1;
}

het zal foutloos compilen met alle warnings aan, maar verder klopt er geen zak van

Hmm ik heb het ff getest:

code:

char      l_String1[] = "Beer";
char      l_String2[] = "Aap";
int       l_Result    = strcmp(l_String1, l_String2);

En hij produceerde netjes als resultaat 1 in de l_Result!

[ Voor 0% gewijzigd door curry684 op 29-08-2002 03:36 . Reden: Indents :( ]

[.oisyn]

het is iig een supersnelle functie... vooral als je m inline't

benchmarken?

[curry684]

.oisyn schreef op 29 augustus 2002 @ 03:37:
benchmarken?

Die fase ben ik voorbij... ik programmeer tegenwoordig binnen zelfontwikkeld framework dat zonder extra coding effort volautomatisch je programma profiled, memory leaks rapporteert en bij exceptions (incluis access violations e.d.) volledige callstacks meelevert.... allemaal ook beschikbaar in releasebuild

Dussuh als ik die functie gebruik krijg ik vanzelf een rapportje over de min/avg/max executietijd, aantal calls en totaal verbruikte CPU-tijd... benchmarks are for the weak

[Dash2in1]

Overigens als het gaat om puur op (on)gelijkheid te checken zou ik eerst even de lengte van beide strings nagaan, die check zit nl niet in de vergelijkingsfunctie ..

edit:

hmm bedenk met dat beide een 150 chars pakken, dus is niet echt nodig.

[Verwijderd]

Dash2in1 schreef op 29 augustus 2002 @ 08:24:
Overigens als het gaat om puur op (on)gelijkheid te checken zou ik eerst even de lengte van beide strings nagaan, die check zit nl niet in de vergelijkingsfunctie ..

edit:

hmm bedenk met dat beide een 150 chars pakken, dus is niet echt nodig.

Nee dus. Om in C de lengte van een string te bepalen moet je de hele string "aflopen" tot de afsluitende '\0', terwijl je de chars telt. Om twee strings te vergelijken moet je ze ook aflopen tot de eerste '\0' of de eerste ongelijke chars. Als je dus eerst de lengte gaat bepalen doe je werk voor niets: je loopt 2x door de strings ipv. 1x; maw je algoritme draait minimaal 2x zo langzaam.

[.oisyn]

sterker nog, als je 2 strings heb met een lengte van 200, en het eerste karakter verschilt al, loop je dus eerst 200 chars te zoeken naar de '/0' om er vervolgens achter te komen dat de eerste char al direct verschilt, zodat het werk van die andere 199 chars voor niets is geweest

[Verwijderd]

.oisyn>> dat zeg ik toch

[.oisyn]

mmja ok maar wat ik wilde zeggen is dat het ook 200x zo langzaam kan gaan

[XeRiOn]

Ik heb geprobeerd de declaraties, de psd's en het programma op te stellen.
Er zullen nog wel veel fouten inzitten, maar misschien kunnen jullie me nog wat aanwijzingen geven.

__________________________________________________________________


__________________________________________________________________
programma

code:

#include <stdio.h>

void main()
{
    char zin1[2][80];
    char zin2[2][80];
    printf("Geef de eerste zin: \");
    gets(zin1);
    printf("Geef de tweede zin: \n");
    gets(zin2);
    vergelijk(zin1,zin2);
    if (gelijk==0)
    printf("de zinnen zijn gelijk aan elkaar: \n");
    if (gelijk==1)
    printf("de zinnen zijn niet gelijk aan elkaar: \n");
    return 0;
}
int vergelijk (char zin1[2][80], char zin2[2][80], int gelijk)
{
    if (zin1!= zin2) gelijk=0;
                if (zin1==zin2) gelijk=1;
                return (gelijk);
}

__________________________________________________________________

barst maar los met commentaar

[Ericston]

Eerstens:

code:

error C2001: newline in constant
error C2146: syntax error : missing ')' before identifier 'gets'
warning C4047: 'function' : 'char *' differs in levels of indirection from 'char [2][80]'
warning C4024: 'gets' : different types for formal and actual parameter 1
warning C4013: 'vergelijk' undefined; assuming extern returning int
error C2065: 'gelijk' : undeclared identifier
warning C4098: 'main' : 'void' function returning a value

Tweestens:
In je stroomdiagram is het misschien wat beter om dichter bij de programmeertaal te gaan zitten. Dus werk die functie vergelijk beter uit (een loopje is misschien handig, lees het topic door voor het geval je dat cruciale punt hebt gemist ) en doe wat aan je kennis van de taal in het algemeen, want de manier waarop jij de declaraties van variabelen opschrijft in zowel de PSD als in je programma is niet ok.

Dus:
maak een loop om de chars (!) van beide zinnen te vergelijken; zin1 is nog altijd een char[]; return maakt niet automatisch een locale variabele global

Ps.
De taal die jij in je PSD gebruikt is misschien beter om als comments achter je code te zetten voor je leraar.

[.oisyn]

tip: zet je code tussen code tags

code:

void main ()

main () moet een int returnen. Hier kom ik nog op terug

code:

char zin1[2][80];
char zin2[2][80];

wat is het nut van die [2] ?

code:

vergelijk(zin1,zin2);
if (gelijk==0)
    printf("de zinnen zijn gelijk aan elkaar: \n");
if (gelijk==1)
    printf("de zinnen zijn niet gelijk aan elkaar: \n");

waar komt de waarde van gelijk vandaan

code:

return 0;

omdat je main () void is kan ie ook geen waarde returnen... maar aangezien het standaard is om m int te maken staat deze statement wel goed

code:

int vergelijk (char zin1[2][80], char zin2[2][80], int gelijk)
{
if (zin1!= zin2) gelijk=0;
if (zin1==zin2) gelijk=1;
return (gelijk);
}

heb je de thread uberhaupt wel gelezen? Er is een hele discussie geweest adh van de code van logik2001 dat je pointers niet met elkaar kunt vergelijken als je strings wilt vergelijken (zin1 en zin2 zullen hier dan ook altijd ongelijk aan elkaar zijn)
en waar komt gelijk vandaan? Die variabele heb je niet gedefinieerd (heb je het sowieso wel geprobeerd te compilen???)

ook kun je het beter schrijven als:

code:

if (zin1 == zin2)
    return 1;
else
    return 0;

of zelfs:

code:

return (zin1 == zin2);

(afgezien van het feit dat je strings zo niet kan vergelijken )

[XeRiOn]

ik kan het programma zelf pas morgen uitproberen omdat ik het thuis er niet op heb staan

[Ericston]

[ Voor 0% gewijzigd door Ericston op 29-08-2002 17:35 . Reden: dubbel ]

[Ericston]

.oisyn schreef op 29 augustus 2002 @ 16:58:
[..]

code:

int vergelijk (char zin1[2][80], char zin2[2][80], int gelijk)
{
if (zin1!= zin2) gelijk=0;
if (zin1==zin2) gelijk=1;
return (gelijk);
}

[..]
en waar komt gelijk vandaan?
[..]

Hier vandaan:

int vergelijk (char zin1[2][80], char zin2[2][80], int gelijk)

Maar is natuurlijk hardstikke fout, lokale variabelen moet je gewoon in de functie body declareren.

[.oisyn]

Ericston schreef op 29 augustus 2002 @ 17:33:
[...]


Hier vandaan:

[...]




Maar is natuurlijk hardstikke fout, lokale variabelen moet je gewoon in de functie body declareren.

[NDF82]

heej, ik heb van men neef de vraag gekregen om dat te schrijven en de code die jij post is exact de mijne, foei foei, heb je een opzet ga je der nog niet mee verder!!!!

[XeRiOn]

hehe lol, dus jij bent de neef van angelo.

Iig nog bedankt voor die opzet

maar zoals je ziet is hij niet echt goed

[NDF82]

yup, de neef van Angelo, maar d8 dat het woorden moesten zijn en wist ook niet dat je geen String functies mocht gebruiken

[Ericston]

Pff.

[.oisyn]

Ik gooi m op slot. Blijkbaar vind je het niet belangrijk om het zelf te doen aangezien je je antwoord van iemand anders gebruikt had. Ook heb je schijnbaar een beetje problemen met lezen aangezien de oplossing wel te construeren is uit de rest van de reacties in deze draad.

Veel succes nog, maar probeer ons niet het huiswerk voor jou te laten maken