[C++] basis: 2 x char[] vergelijken lukt niet

[Tha Man]

Hoi,

Ik heb een opdracht voor school waarbij ik 2 chars[] moet vergelijken, en waarbij ik een hulpfunctie toUpper heb, waarmee alle lowercase naar Uppercase veranderd worden, en indien Uppercase, gebeurt er niks mee (uiteraard ).

Ik heb de volgende code al opgesteld (had soortgelijke opdracht hiervoor, die was case-gevoelig, en dus simpeler, waardoor ik al iets had om vanuit verder te werken), maar op de een of andere manier krijg ik toch een false mededeling bij deze chars[], terwijl er natuurlijk true uit zou moeten komen...

C++:

#include <iostream>

using namespace std ;

char toUpper (int c){
    return c; 
}

bool equalsIgnoreCase (char s1 [], char s2 []){
    for (int pos = 0; s1[pos] != '\0' || s2[pos] != '\0'; pos++)    {
        s1[pos] = toUpper (s1[pos]);
        s2[pos] = toUpper (s2[pos]);

        if (s1[pos] != s2[pos])     {
            cout << "false\t" ; 
            return false ;
        }
    }
    cout << "true\t" ;
    return true; 
}

void main (){
    char s1[] = "hallo";
    char s2[] = "halLo"; 

    equalsIgnoreCase (s1,s2) ;
}

Iemand een idee waar het aan kan liggen?

[beany]

mja, je toUpper functie doet erg weinig. Krijgt wat binnen, en gooit het weer terug zonder er iets mee te doen

[Verwijderd]

beany schreef op donderdag 23 februari 2006 @ 14:02:
mja, je toUpper functie doet erg weinig. Krijgt wat binnen, en gooit het weer terug zonder er iets mee te doen

En je krijgt een int binnen Moet volgens mij een char zijn...

[Tha Man]

Ow damn....ik dacht serieus dat het, gezien het voorgedefinieerde functie was (zo werd het uitgelegd), dit vanuit een library wel geregeld werd

Wellicht hebben jullie een idee hoe je een dergelijke functie op kan zetten? Kan toch niet te ingewikkeld zijn....(hoop ik) ?

[beany]

Aangezien dit een school opdracht is, ga ik je geen kant en klaar antwoord geven. Wat ik wel kan zeggen is dat er zat op google te vinden over het omzetten naar hoofdletters, ook voor C++. Als je Visual Studio gebruik is er zelfs in de MSDN help wel dingen over te vinden!

edit: HIGHGuY denkt er blijkbaar anders over

[ Voor 9% gewijzigd door beany op 23-02-2006 14:10 ]

[H!GHGuY]

C++:

char toUpper(char c)
{
  if (c >= 'a' && c <= 'z')
      c += 'A' - 'a';
  return c;
}

bovendien heeft jouw functie de nevenwerking dat alle tekens die vergeleken worden na vergelijken in uppercase staan:
voor:
s1 = "een String"
s2 = "een Str"
na:
s1 = "EEN STRing"
s2 = "EEN STR"

beter is dus:

C++:

if (toUpper(s1[pos]) != toUpper(s2[pos]))
   return false;

ook is je stopconditie fout van je for-loop...
bovendien is het daar aangewezen om een while-loop te gebruiken, geen for-loop

[ Voor 20% gewijzigd door H!GHGuY op 23-02-2006 14:08 ]

[.oisyn]

Tha2Man schreef op donderdag 23 februari 2006 @ 14:05:
Ow damn....ik dacht serieus dat het, gezien het voorgedefinieerde functie was (zo werd het uitgelegd), dit vanuit een library wel geregeld werd

Dan moet je natuurlijk niet met een eigen implementatie op de proppen komen. Nu werkt het toch gewoon precies zoals het er staat? toUpper retourneert gewoon de waarde die je 'm geeft, dat er ook een toUpper in de library bestaat doet er voor de compiler niet meer toe; je hebt er zelf al een gegeven. Overigens bestaat er geen toUpper in de standaard library, wel een toupper overigens.

[Tha Man]

beany schreef op donderdag 23 februari 2006 @ 14:07:
Aangezien dit een school opdracht is, ga ik je geen kant en klaar antwoord geven. Wat ik wel kan zeggen is dat er zat op google te vinden over het omzetten naar hoofdletters, ook voor C++. Als je Visual Studio gebruik is er zelfs in de MSDN help wel dingen over te vinden!

edit: HIGHGuY denkt er blijkbaar anders over

hehe, blijkbaar ja Ik heb inmiddels e.e.a. gevonden en dat komt er wel min of meer op neer wat hij duidelijk maakt..

Beiden bedankt

[Tha Man]

HIGHGuY schreef op donderdag 23 februari 2006 @ 14:07:

C++:

char toUpper(char c)
{
  if (c >= 'a' && c <= 'z')
      c += 'A' - 'a';
  return c;
}

......

ook is je stopconditie fout van je for-loop...
bovendien is het daar aangewezen om een while-loop te gebruiken, geen for-loop

C++:

bool equalsIgnoreCase (char s1 [], char s2 [])
{
    int pos = 0 ;
    while (s1[pos] != '\0' || s2[pos] != '\0'){
         if (toUpper(s1[pos]) != toUpper(s2[pos])){
             cout << "false" << endl ;
             return false;
         }
        if (s1[pos] != s2[pos]){
            cout << "false\t" ; 
            return false ;
        }
    }
    cout << "true\t" ;
    return true; 
}

Dit levert me een oneindige loop op, niet heel handig

Mijn stopconditie lijkt me echter niet fout, want hij geeft toch heel duidelijk aan tot waar de loop moet lopen?
De conditie moet volgens mij gewoon zijn dat een van beide chars[] op z'n eindpunt beland is, en dat geef ik toch ook aan in die conditie?

[ Voor 48% gewijzigd door Tha Man op 23-02-2006 14:28 ]

[beany]

hmmm, bijna... de while gaat door zolang s1[pos] niet op het einde is OF s2[pos] niet op het einde is. De while gaat door zolang 1 van die 2 vergelijkingen true is. de || (OR) word aan beide kanten namelijk gechecked.

Stel s1[pos] == 0 , dan wordt er ook nog gekeken naar s2[pos]. Als die iets anders is dan 0, gaat de while door met alle gevolgen van dien.

[IcE_364]

Dat wat beany zegt en natuurlijk je pos zelf incrementen, want dat gebeurt nu ook niet...

[ Voor 24% gewijzigd door IcE_364 op 23-02-2006 15:14 ]

[Tha Man]

Hello,

Ik heb 'm nu met deze code hieronder werkend! Merci bien allemaal, 't was nuttig te lezen!

C++:

bool equalsIgnoreCase (char s1 [], char s2 [])
{
    int pos = 0 ;
    while (s1[pos] != '\0' || s2[pos] != '\0')
    {
        
         if (toUpper(s1[pos]) != toUpper(s2[pos]))
         {
             cout << "false" << endl ;
             return false;
         }
         pos++ ;
    }
    cout << "true\t" ;
    return true; 
}

[beany]

Ehm, toch is je stopconditie in je while fout!!!! Maar als ik je bovenstaande post zo lees maakt dat je weinig uit??

[IcE_364]

Zoals beany (2x nu )al zei moet je je while loop even veranderen naar &&,

Nu gaat hij alleen goed zolang de strings even lang zijn. Als er een langer is als de ander zal de loop gewoon doorgaan en gaat het fout.

[ Voor 5% gewijzigd door IcE_364 op 23-02-2006 16:04 ]

[remco_k]

IcE_364 schreef op donderdag 23 februari 2006 @ 16:03:
Zoals beany (2x nu )al zei moet je je while loop even veranderen naar &&,

Nu gaat hij alleen goed zolang de strings even lang zijn. Als er een langer is als de ander zal de loop gewoon doorgaan en gaat het fout.

Alleen naar && veranderen is niet goed, want dan zou dit:

s1='effe wat testen hoor'
s2='effe WAT testen'

volgens bovenstaande code gelijk zijn aan elkaar en dat is natuurlijk een fout antwoord.

De || die de TS er nu zelf in heeft zitten is beter, maar hij moet er nog wel iets bijmaken want het gaat niet goed komen zo.

[ Voor 15% gewijzigd door remco_k op 23-02-2006 16:20 ]

[Woy]

Dan return je toch gewoon zo

C++:

return s1[ pos ] == s2[ pos ];

dan is het wel weer correct.

[remco_k]

rwb schreef op donderdag 23 februari 2006 @ 16:20:
Dan return je toch gewoon zo

C++:

return s1[ pos ] == s2[ pos ];

dan is het wel weer correct.

Hij moet een array van chars vergelijken en daarbij ook nog eens case insensitive.
Wat jij hier laat zien slaat als een tang op een varken.

[IcE_364]

remco_k schreef op donderdag 23 februari 2006 @ 16:18:
[...]

Alleen naar && veranderen is niet goed, want dan zou dit:

s1='effe wat testen hoor'
s2='effe WAT testen'

volgens bovenstaande code gelijk zijn aan elkaar en dat is natuurlijk een fout antwoord.

De || die de TS er nu zelf in heeft zitten is beter, maar hij moet er nog wel iets bijmaken want het gaat niet goed komen zo.

True, zover had ik nieteens gekeken, maar de || klopt ook niet echt, in dit geval wel maar dat is meer om die andere fout te corigeren.

[curry684]

* curry684 bored:

C++:

#include <iostream>
using namespace std;

inline char toUpper(const char ch)
{
    return ch >= 'a' && ch <= 'z' ? ch - ('a' - 'A') : ch;
}

bool mystricmp(const char* left, const char* right)
{
    while(*left && *right && toUpper(*(left++)) == toUpper(*(right++)));
    return !(*left || *right);
}

int main()
{
    if(mystricmp("Hello", "heLLo"))
        cout << "Equal";
    else
        cout << "Not Equal";
    cin.get();
    return 0;
}

[BoAC]

remco_k schreef op donderdag 23 februari 2006 @ 16:22:
[...]

Hij moet een array van chars vergelijken en daarbij ook nog eens case insensitive.
Wat jij hier laat zien slaat als een tang op een varken.

Voor de loop checken op lengte scheelt een hoop tijd en dan is de oplossing van TS wel correct.

@urry684: beter

[ Voor 5% gewijzigd door BoAC op 23-02-2006 16:32 ]

[remco_k]

BoAC schreef op donderdag 23 februari 2006 @ 16:25:
[...]

Voor de loop checken <knip> en dan is de oplossing van TS wel correct.

Jah, jij geeft het lekker weg aan de TS.
Ik dacht, ik zeg het niet, dan leert ie er wat van.

Als jij je post nou effe edit tot iets onleesbaars... Dan kan de TS ook zelf nog effe denken.

Edit:
OMG! La maar.

[ Voor 6% gewijzigd door remco_k op 23-02-2006 16:29 ]

[curry684]

Leuke is dat ie aan die oplossing van mij toch geen bal heeft als ie niet kan uitleggen wat er staat

[.oisyn]

Probeer zelf eens de werking uit te leggen dan, want hij klopt niet

[remco_k]

.oisyn schreef op donderdag 23 februari 2006 @ 16:40:
Probeer zelf eens de werking uit te leggen dan, want hij klopt niet

Hij klopt wel maar hij deugt niet

C++:

bool mystricmp(const char* left, const char* right)

const char* ?
Het kan aan mij liggen, maar const heeft hier niet echt veel nut / toegevoegde waarde.

[.oisyn]

Helaas, hij klopt niet maar hij deugt wel . const heeft daar zeker wel nut, mystricmp mag de contents van de strings namelijk niet aanpassen. En ik tel zo 2 fouten die ervoor zorgen dat het niet werkt, op regel 11 en 12.

[ Voor 22% gewijzigd door .oisyn op 23-02-2006 16:44 ]

[curry684]

Ik verveelde me niet lang genoeg om grondig te testen, maar met een heel aantal test strings werkte ie perfect hoor

[riezebosch]

curry684 schreef op donderdag 23 februari 2006 @ 16:32:
Leuke is dat ie aan die oplossing van mij toch geen bal heeft als ie niet kan uitleggen wat er staat

Hij's fijn. Maar doet ie 't ook helemaal goed? Want voor de return hoeft óf left óf right maar goed te zijn. Kan dus zijn dat de strings gedeeltelijk gelijk zijn, zoals HIGHGuY al aangaf

Ze moeten natuurlijk allebei false zijn om 'm weer true te maken

[ Voor 19% gewijzigd door riezebosch op 23-02-2006 16:51 ]

[remco_k]

.oisyn schreef op donderdag 23 februari 2006 @ 16:43:
Helaas, hij klopt niet maar hij deugt wel . const heeft daar zeker wel nut, mystricmp mag de contents van de strings namelijk niet aanpassen.

De grap van deze code is dat dat ook niet gebeurd.
Heb je het getest in je compiler... ik wel, en het werkt prima.

En ik tel zo 2 fouten die ervoor zorgen dat het niet werkt, op regel 11 en 12.

Ik zie ze niet - code ziet er imo goed uit en werkt correct.

[.oisyn]

Dan heb je de verkeerde teststrings gebruikt . Het is trouwens maar 1 fout, die logische or gaat wel goed itt wat ik dacht.

spoiler:

Je verhoogt left en right ookal zijn de chars ongelijk aan elkaar. De while lus wordt dan gestopt, maar left en right wijzen dan al naar het volgende teken. De logische or op de volgende char heeft natuurlijk weinig nut. De bug treedt pas op als de twee strings pas bij het laatste teken verschillen, omdat *left en *right dan 0 zijn en het resultaat dus op equal uitkomt

remco_k schreef op donderdag 23 februari 2006 @ 16:51:
[...]

De grap van deze code is dat dat ook niet gebeurd.

Je begrijpt het niet helemaal. Een stringcompare mag de contents van strings niet veranderen, hij leest alleen maar. Als je een functie hebt die werkt op een pointer, waarbij de data waarna gepoint wordt niet veranderd wordt, is het handig om die parameters const te maken zodat iemand die const data heeft die functie óók kan gebruiken. Met jouw redenatie heeft const-correctheid nooit nut

Heb je het getest in je compiler... ik wel, en het werkt prima.

Dat het bij het voorbeeld goed gaat wil uiteraard niet zeggen dat het altijd goed gaat . Test "Hello1" maar eens met "Hello2", de functie zal zeggen dat ze equal zijn.

[ Voor 66% gewijzigd door .oisyn op 23-02-2006 17:01 ]

[BoAC]

.oisyn schreef op donderdag 23 februari 2006 @ 16:52:
Dan heb je de verkeerde teststrings gebruikt . Het is trouwens maar 1 fout, die logische or gaat wel goed itt wat ik dacht.

spoiler:

Je verhoogt left en right ookal zijn de chars ongelijk aan elkaar. De while lus wordt dan gestopt, maar left en right wijzen dan al naar het volgende teken. De logische or op de volgende char heeft natuurlijk weinig nut. De bug treedt pas op als de twee strings pas bij het laatste teken verschillen, omdat *left en *right dan 0 zijn en het resultaat dus op equal uitkomt

[...]


Dat het bij het voorbeeld goed gaat wil uiteraard niet zeggen dat het altijd goed gaat . Test "Hello1" maar eens met "Hello2", de functie zal zeggen dat ze equal zijn.

De laatste character-compare wordt dan dus niet gedaan

spoiler:

while(*left && *right && toUpper(*(left)) == toUpper(*(right))){ left++; right++; }

[remco_k]

.oisyn schreef op donderdag 23 februari 2006 @ 16:52:
...
Dat het bij het voorbeeld goed gaat wil uiteraard niet zeggen dat het altijd goed gaat . Test "Hello1" maar eens met "Hello2", de functie zal zeggen dat ze equal zijn.

haha! ja je hebt gelijk.
Ik had enkel getest met teksten als "HaLLo1a" en " HalLo2A" en dat valt niet opn dan..

[Tha Man]

IcE_364 schreef op donderdag 23 februari 2006 @ 16:23:
[...]


True, zover had ik nieteens gekeken, maar de || klopt ook niet echt, in dit geval wel maar dat is meer om die andere fout te corigeren.

Wellicht dat ik er dan echt iets niet van begrijp, maar als ik

C++:

bool equalsIgnoreCase (char s1 [], char s2 [])
{
    int pos = 0 ;
    while (s1[pos] != '\0' || s2[pos] != '\0')
    {
        
         if (toUpper(s1[pos]) != toUpper(s2[pos]))
         {
             cout << "false" << endl ;
             return false;
         }
         pos++ ;
    }
    cout << "true\t" ;
    return true; 
}

void main ()
{
    char s1[] = "effe wat testen hoor" ;
    char s2[] = "effe WAT testen"; 

    equalsIgnoreCase (s1,s2) ;

invoer, dan krijg ik toch echt false te zien, en geen true: wat dus het juiste antwoord is..

Wat klopt er dan niet aan de code?

[.oisyn]

Kijk je überhaupt wel wat er staat? Gebruik anders een debugger. Je ziet toch dat de while lus stopt zodra s1[pos] == 0 óf s2[pos] == 0? En dus als één van de twee 0 is dat dat niet automatisch betekent dat ze gelijk aan elkaar zijn?

[ Voor 27% gewijzigd door .oisyn op 23-02-2006 17:42 ]

[Tha Man]

.oisyn schreef op donderdag 23 februari 2006 @ 17:41:
Kijk je überhaupt wel wat er staat? Gebruik anders een debugger. Je ziet toch dat de while lus stopt zodra s1[pos] == 0 óf s2[pos] == 0? En dus als één van de twee 0 is dat dat niet automatisch betekent dat ze gelijk aan elkaar zijn?

Dat betekend dan toch ook dat als 1 v.d. 2 nog doorloopt, de lengte van de een afwijkt van de ander, en de strings dus per definitie niet gelijk zijn aan elkaar?
Daar ging het o.a. om...

[.oisyn]

Ja, maar toch return je dat ze dan gelijk zijn. Dus wat klopt er dan niet aan de code?

[ Voor 35% gewijzigd door .oisyn op 23-02-2006 17:49 ]

[Tha Man]

.oisyn schreef op donderdag 23 februari 2006 @ 17:48:
Ja, maar toch return je dat ze dan gelijk zijn. Dus wat klopt er dan niet aan de code?

Ow crap...ik begrijp nu wat je bedoelt. Ik geef idd nu dat ze gelijk zijn, krijg daarom ik false als return...

K, ff goed lezen nog

[WormLord]

.oisyn schreef op donderdag 23 februari 2006 @ 17:41:
Kijk je überhaupt wel wat er staat? Gebruik anders een debugger. Je ziet toch dat de while lus stopt zodra s1[pos] == 0 óf s2[pos] == 0? En dus als één van de twee 0 is dat dat niet automatisch betekent dat ze gelijk aan elkaar zijn?

Tha2Man schreef op donderdag 23 februari 2006 @ 17:37:
[...]

C++:

    while (s1[pos] != '\0' || s2[pos] != '\0')

[...]

Mischien dat ik iets mis hoor, maar deze while stopt toch alleen als s1[pos] en s2[pos] 0 zijn? Als slechts 1 een van de twee 0 is, dan gaat de code kijken of ze gelijk zijn en ziet dan dat dat niet zo is (de ene is 0, de andere niet) en voila, hij returnd false. Toch?

[Woy]

remco_k schreef op donderdag 23 februari 2006 @ 16:22:
[...]

Hij moet een array van chars vergelijken en daarbij ook nog eens case insensitive.
Wat jij hier laat zien slaat als een tang op een varken.

Tuurlijk heeft dat wel nut. Als je zo na de loop controleert kijk je of beide chars 0 zijn. Hij springt namelijk uit de loop als een van beide chars 0 is ( als je && gebruikt tenminste ) als beide chars dan niet gelijk aan elkaar zijn dan zijn de strings dus niet even lang.

BoAC schreef op donderdag 23 februari 2006 @ 16:25:
[...]

Voor de loop checken op lengte scheelt een hoop tijd en dan is de oplossing van TS wel correct.

@urry684: beter

Dat kan natuurlijk wel maar het is niet zo handig om 2 maal strlen te doen aangezien je dan al 2 keer door een string geloopt ben om de lengte te bepalen en daarna ga je dat nog zelf doen .

[.oisyn]

WormLord schreef op vrijdag 24 februari 2006 @ 08:14:
Mischien dat ik iets mis hoor, maar deze while stopt toch alleen als s1[pos] en s2[pos] 0 zijn? Als slechts 1 een van de twee 0 is, dan gaat de code kijken of ze gelijk zijn en ziet dan dat dat niet zo is (de ene is 0, de andere niet) en voila, hij returnd false. Toch?

Je hebt helemaal gelijk, ik heb zelf niet goed gelezen. Ook niet wat de TS erover zei, want hij zei al dat ie false kreeg, en dat klopt wel degelijk met die strings. Ik zie nu pas dat hij volgens mij reageerde op een eerdere opmerking van remco_k. Z'n code klopt gewoon. Mijn excuus

De while stopt alleen als beide 0 zijn, en als dat het geval is zijn ze dus gelijk. Als een van de twee 0 is gaat de lus door maar zijn ze ongelijk aan elkaar en dus wordt er false gereturned in de lus zelf.

[ Voor 14% gewijzigd door .oisyn op 24-02-2006 11:32 ]

[jos707]

Is het zowieso niet echt slim om voorbij het einde van een array te checken ? Want dan kan
je gelijk wat tegenkomen.

[.oisyn]

Dat moet je idd niet doen, maar wie doet dat dan?

[ Voor 17% gewijzigd door .oisyn op 24-02-2006 12:47 ]

[jos707]

.oisyn schreef op vrijdag 24 februari 2006 @ 12:46:
Dat moet je idd niet doen, maar wie doet dat dan?

Ik had het op het bovenstaand stukje code van Tha2Man, pos blijft oplopen terwijl één van beide
arrays misschien al aan zijn einde zit. Dus dan zit je een onbekende waarde te checken.

C++:

while (s1[pos] != '\0' || s2[pos] != '\0') 
    { 
         
         if (toUpper(s1[pos]) != toUpper(s2[pos])) 
         { 
             cout << "false" << endl ; 
             return false; 
         } 
         pos++ ; 

Of misschien heb ik het niet helemaal begrepen

[.oisyn]

Het zijn C-style strings, die eindigen per definitie op een 0. En aangezien hij stopt zodra één van de twee 0 is (of ze zijn beide 0 waardoor de while wordt gestopt, of één van de twee is 0 zodat de toUpper() vergelijking false oplevert) zal je dus nooit buiten de boundaries van de array komen.

[jos707]

.oisyn schreef op vrijdag 24 februari 2006 @ 15:20:
Het zijn C-style strings, die eindigen per definitie op een 0. En aangezien hij stopt zodra één van de twee 0 is (of ze zijn beide 0 waardoor de while wordt gestopt, of één van de twee is 0 zodat de toUpper() vergelijking false oplevert) zal je dus nooit buiten de boundaries van de array komen.

Dat is het juist, hoe weet je 100% zeker dat die toUpper false zal teruggeven wanneer één van beide
arrays op zijn einde zit. Je zit hier namelijk een onbekende waarde te vergelijken die misschien wel eens heel toevallig dezelfde waarde zou kunnen zijn als in de de andere array die nog niet 0 is waardoor je geen false maar een true terugkrijgt.
Of klets ik nu gewoon uit mijn nek ?

[Woy]

Ja je kletst uit je nek

stel je hebt

s1 = "a"
s2 = "ab"

op het moment dat je index 1 hebt dan levert s1[ 1 ] een 0 character op en s2[ 1 ] een 'b'

dus uiteindelijk vergelijk je 0 == 'B' wat dus false oplevert.

[ Voor 26% gewijzigd door Woy op 24-02-2006 15:43 ]

[farlane]

Vind het op een of andere manier heel onlogische code, door die || .

[jos707]

rwb schreef op vrijdag 24 februari 2006 @ 15:39:
Ja je kletst uit je nek

stel je hebt

s1 = "a"
s2 = "ab"

op het moment dat je index 1 hebt dan levert s1[ 1 ] een 0 character op en s2[ 1 ] een 'b'

dus uiteindelijk vergelijk je 0 == 'B' wat dus false oplevert.

Ok het lag aan mij dus. Ik had uit het oog verloren dat er tussen het einde van de array en het onbekende altijd een 0 staat wat zowieso altijd false zal teruggeven.
Het weekend was voor mij al begonnen denk ik..