[C++][SCHOOL]klinkers verwijderen

[gitaarwerk]

Hoi, ik ben nogal n00b met c++, en aangezien we een schoolproject moeten maken met c++ is het best wel irritant als je veel probeert maar telkens de fout in gaat

het is de bedoeling om een functie te schrijven waarbij unit tests worden gedaan.
Alle units tests moeten slagen, maar bij de 2e gaat ie al de mist in.
Ik heb echt geen flauw idee waar te gaan beginnen met oplossen.. ik weet hoe je een letter moet zoeken en verwijderen wel.. maar probleem met een loop kan ik niet oplossen.

hier stukje code

code:

bool VerwijderdeKlinkers(string woordMetKlinkers, string woordZonderKlinkers)
{
    if ((woordMetKlinkers == "") && (woordZonderKlinkers == ""))
    {
        return true;
    }


                for (int i = 0; i < woordMetKlinkers.find("a"); i++)        {

            // schrijf teller naar scherm
            cout << woordMetKlinkers << endl;
        }


}

hierboven de functie om de letter te zoeken.
en hieronder de unit test

code:

bool VerwijderdeKlinkersTest()
{
    if (VerwijderdeKlinkers("", "") != true)  
    {
        return false;
    }

    if (VerwijderdeKlinkers("aoeiu", "") != true)
    {
        return false;
    }
/*

    if (VerwijderdeKlinkers("smurf", "") == false)
    {
        return false;
    }

    if (VerwijderdeKlinkers("", "smurf") == false)
    {
        return false;
    }

    if (VerwijderdeKlinkers("+(-/)*", "*(/-)+") == false)
    {
        return false;
    }

    if (VerwijderdeKlinkers("+(-/)*", "+(-/)*") == true)
    {
        return false;
    }

    if (VerwijderdeKlinkers("azrael", "azrael") == false)
    {
        return false;
    }
        
    if (VerwijderdeKlinkers("de fluit met de 7 smurfen", "d flt mt d 7 smrfn") == true)
    {
        return false;
    }

    if (VerwijderdeKlinkers("de fluit met de 7 smurfen", "dfltmtd7smrfn") == false)
    {
        return false;
    }
*/
    return true;

}

achter void main word het programma uitgevoerd (zoals gewoonlijk ) maar dat werkt perfect, aangezien we die een standard hebben gekregen.. het is dus aan ons om de functies te maken.

wat het probleem is bij de klinkers is dat dus telkends de 'i' maar 1x gebrukt kan worden (zoals 1e stukje) verder ben ik ervan bewust dat in de unit tests nu alleen de 1 (hierboven) staat " om uit te voeren"

bij de 2e geeft ie geneens het woord weer...
hellup

[ Voor 18% gewijzigd door gitaarwerk op 06-01-2003 11:09 ]

[SWfreak]

Als je goed kijkt naar wat je for-loop doet, zal je er snel achterkomen waarom ie niets weergeeft...

[gitaarwerk]

ik ken dat.. dat is nu opgelost.. als ik

code:

    for (int i = 0; i < woordMetKlinkers.find("a") || woordMetKlinkers.find("o") ; i++)

gebruik.. nu geeft ie de volgende foutmelding
"C:\Program Files\Microsoft Visual Studio\MyProjects\VerwijderdeKlinkers\VerwijderdeKlinkers.cpp(34) : warning C4715: 'VerwijderdeKlinkers' : not all control paths return a value"
maar dan werkt het erase commando die ik erbij hebt gedaan niet
(binnen de loop)

code:

woordMetKlinkers.erase("a");

edit : stupid
post zometeen wel weer als ik wat doms heb weggehaald

[ Voor 14% gewijzigd door gitaarwerk op 06-01-2003 11:20 ]

[whoami]

't is geen error maar een warning. En ga eens na wat die warning wil zeggen.
Die krijg je bv als je het volgende doet:

code:

bool returnFunction( int a)
{
  if( a == 1 )
  {
     return true;
  }
}

en is opgelost als je bv:

code:

bool returnFunction( int a)
{
  if( a == 1 )
  {
     return true;
  }
  else
  {
     return false;
  }
}

doet.

[gitaarwerk]

dat is inderdaad een oplossing voor die warning ja, maar die unit tests zouden moeten kloppen, aangezien we daarmee MOETEN werken

verder merk ik nu nog wat wat nog veel vervelender is.. we moeten dus die functie goed maken

maar ik was vergeten dat je met coordinaten moet werken van de letters..
nu moet ik dus een loop maken waar die eerst het aantal letters van moet zoeken,
dan van 0 tot X lengte iedere klinker meot zoeken en verwijderen..

is het dan handig om een lengte te tellen buiten de loop? en op te slaan in een int?

[Soultaker]

Misschien moet je eens een andere aanpak proberen. Je codeert nu bijvoorbeeld al speciale gevallen (lege strings) terwijl dit probleem prima met een enkele, algemeen toepasbare oplossing op te lossen is.

Meestal probeer ik zelf in dit soort gevallen mijn 'eigen' werkwijze te coderen. Als je op papier de klinkers zou moeten verwijderen, dan zou je de string van begin tot eind doorlopen en de klinkers, wanneer je die tegenkomt, doorstrepen. Vervolgens schrijf je de string zonder doorgestreepte tekens op het papier.

Als je de C++ string hebt bestudeerd, dan weet je dat erase iterators invalideert en dat is natuurlijk erg vervelend als je de strings wilt doorlopen. Gelukkig wil je hier geen nieuwe string construeren, maar simpelweg verifiëren dat de ene string (op de klinkers na) gelijk is aan de andere string.

Je hoeft dus nooit klinkers te erasen, maar simpelweg beide strings te doorlopen. In de eerste string (MET klinkers) sla je de klinkers over; de niet-klinkers (medeklinkers en andere karakters) vergelijk je met de tweede string. In pseudo-code wordt dat dus zoiets:

code:

posititie_1 = (begin van string1); posititie_2 = (begin van string2);
while(positie_1 of positie_2 nog niet aan het einde van de string)
{
    if(karakter op positie_1 is klinker)
    {
        verhoog positie_1; // klinker overslaan
    }
    else
    {
        if(karakter op positie_1 ongelijk aan karakter op positie_2)
            return false; // ze komen dus NIET overeen!
        verhoog positie_1; verhoog positie_2;
    }
}
if(positie_1 of positie_2 nog niet aan het einde van de string)
    return false; // een van beide strings was langer dan de andere
                 // dan zijn ze dus niet gelijk!

Het laatste statement is nodig om te voorkomen dat "blaat" en "bltxxx" onterecht als 'gelijk' worden aangemerkt. De middelste lus is ook nog wel anders te formuleren. Als je goed begrijpt wat je eigenlijk wil doen, kun je zelf wel bedenken hoe het allemaal nog meer kan. Succes ermee!

[Jochem Knoops]

Misschien nog een kleine tip (en verbeter me maar als het niet zo is)
Volgens mij moet je in c++ string's vergelijken met de functie strcmp ipv string1 == string2
als je dus het == teken gebruikt dan vegrlijk je de adreswaarden. Ik rpogrammeer alweer een tijdje in java dus helemaal zeker ben ik niet. Maar misschien helpt het je toch, succes.

edit:

http://www.cplusplus.com/ref/cstring/strncmp.html

[ Voor 11% gewijzigd door Jochem Knoops op 06-01-2003 11:40 ]

[whoami]

JochemKnoops schreef op 06 January 2003 @ 11:37:
Misschien nog een kleine tip (en verbeter me maar als het niet zo is)
Volgens mij moet je in c++ string's vergelijken met de functie strcmp ipv string1 == string2
als je dus het == teken gebruikt dan vegrlijk je de adreswaarden. Ik rpogrammeer alweer een tijdje in java dus helemaal zeker ben ik niet. Maar misschien helpt het je toch, succes.

Da's te zien.... Als de TS een datatype 'string' gebruikt waarin de == operator geoverloaded is, dan kan dat perfect.
Indien de TS gewoon character arrays gebruikt, moet hij idd strcmp of strcmpi gebruiken.

Maar ik denk wel dat het hier om een string-datatype gaat met een == operator.

[Soultaker]

JochemKnoops schreef op 06 januari 2003 @ 11:37:
Misschien nog een kleine tip (en verbeter me maar als het niet zo is)
Volgens mij moet je in c++ string's vergelijken met de functie strcmp ipv string1 == string2
als je dus het == teken gebruikt dan vegrlijk je de adreswaarden.

In C++ vergelijk je met == nooit de adressen van variabelen (tenzij de klasse in kwestie de ==-operator precies zo geïmplementeert heeft dat dat juist wel gebeurd, wat meestal niet zinnig is). Uitsluitend wanneer je pointers gebruikt, is dit het geval. Dit is een belangrijk verschil met Java, waarin alle variabelen references zijn, maar feitelijk als pointers vergeleken worden. Eigenlijk zijn C++ pointers niet eens een uitzondering: de inhoud van een pointer-variabele is simpelweg een geheugenadres, dus ook bij een pointervariabele vergelijk je de inhoud van je variabelen (en niet het adres waarop deze zich toevallig bevinden).

Ik neem aan dat de topic starter gebruik maakt van de standaard STL string klasse (gezien het nivo van zijn code en het ontbreken van verdere informatie) en dan is de == operator op strings gewoon gedefinieerd als een inhoudelijke vergelijking. Het gebruik van == is dus gewoon goed.

[ Voor 12% gewijzigd door Soultaker op 06-01-2003 11:47 ]

[Janoz]

Wat verwacht je trouwens dat

code:

i < woordMetKlinkers.find("a") || woordMetKlinkers.find("o")

op test?

[gitaarwerk]

zoveel weet ik er dus niet vanaf.. ik weet wel hoe php een beetje werkt nu.. maar dan nog..
wat het dus is als ik je begrijp Soultaker, is dat je een 1e string met een 2e string wilt vergellijken.. dat mogen we dus niet..want hij moet vanuit 1 enkel woord maar een input krijgen.. dus ik mag niet een woord Met en Zonder klinkers gebruiken..(anders zou het makkelijker worden)
ik moet ze dus letterlijk verwijderen..

[gitaarwerk]

Janoz schreef op 06 januari 2003 @ 11:46:
Wat verwacht je trouwens dat

code:

i < woordMetKlinkers.find("a") || woordMetKlinkers.find("o")

op test?

klasgenoot en ik dachten misschien dat je in EEN loop misschien meerdere klinkers tegelijk zouden vinden en te verwijderen, maar we zijn er inmiddels achter dat dat niet gaat werken (zie mijn n00bheid)

[Soultaker]

Gitaarwerk schreef op 06 januari 2003 @ 11:47:
zoveel weet ik er dus niet vanaf.. ik weet wel hoe php een beetje werkt nu.. maar dan nog..
wat het dus is als ik je begrijp Soultaker, is dat je een 1e string met een 2e string wilt vergellijken.. dat mogen we dus niet..want hij moet vanuit 1 enkel woord maar een input krijgen.. dus ik mag niet een woord Met en Zonder klinkers gebruiken..(anders zou het makkelijker worden)
ik moet ze dus letterlijk verwijderen..

Dat vind ik gek. De interface van je functie doet vermoeden dat je de strings moet vergelijken en dan is elke implementatie die daaraan voldoet geldig. Maar goed, dat zal wel weer zo'n gekke schoolopdracht zijn.

In dat geval raad ik je aan om niet de klinkers te verwijderen, maar om uit de eerste string een nieuwe string te construeren zonder klinkers. Je zult dan weer de string moeten doorlopen en alle niet-klinkers aan een tijdelijke string moeten toevoegen. Dit is makkelijker dan bij een eerste string beginnen en een voor een alle klinkers eruit te verwijderen.

[whoami]

[nohtml]

Soultaker schreef op 06 januari 2003 @ 11:45:
[...]

In C++ vergelijk je met == nooit de adressen van variabelen (tenzij de klasse in kwestie de ==-operator precies zo geïmplementeert heeft dat dat juist wel gebeurd, wat meestal niet zinnig is). Uitsluitend wanneer je pointers gebruikt, is dit het geval. Dit is een belangrijk verschil met Java, waarin alle variabelen references zijn, maar feitelijk als pointers vergeleken worden. Eigenlijk zijn C++ pointers niet eens een uitzondering: de inhoud van een pointer-variabele is simpelweg een geheugenadres, dus ook bij een pointervariabele vergelijk je de inhoud van je variabelen (en niet het adres waarop deze zich toevallig bevinden).

Als je 2 character arrays met elkaar gaat vergelijken, ga je afaik idd de adressen met elkaar gaan vergelijken als je deze code gebruikt:

code:

if ( CharArr1 == CharArr2 )

Als je nl.

code:

cout << CharArr1 ;

doet, zul je het adres krijgen van het eerste element van die CharArr1.

Tot zover deze offtopic reactie.

[Soultaker]

whoami schreef op 06 January 2003 @ 11:50:
[nohtml]
Als je 2 character arrays met elkaar gaat vergelijken, ga je afaik idd de adressen met elkaar gaan vergelijken als je deze code gebruikt:

code:

if ( CharArr1 == CharArr2 )

Maar in C++ gebruiken we objecten. Een string is ook een object en voor diverse collectietypen worden in principe ook objecten gebruikt. Een ouderwetse C array is inderdaad een simpele pointer naar het type dat erin zit en als je die vergelijkt, vergelijk je inderdaad de geheugenaddressen (maar dat is nog steeds de waarde of inhoud van die pointervariabelen!).

Als je nl.

code:

cout << CharArr1 ;

doet, zul je het adres krijgen van het eerste element van die CharArr1.

Nee hoor. Bij mij is operator ostream::<< nog altijd overloaded voor character-pointers en geeft 'ie dus gewoon een mooie string weer (anders zou code als: cout << "blaat"; ook niet werken).

Voor pointers naar void of andere typen waar cout niets mee kan, wordt inderdaad wel de adreswaarde in de pointer weergegeven. Dit alles heeft echter meer te maken met de implementatie van ostream, dan met de werking van de taal C++ (al is C++ natuurlijk meer dan de taal alleen).

[ Voor 15% gewijzigd door Soultaker op 06-01-2003 11:56 ]

[gitaarwerk]

Soultaker schreef op 06 januari 2003 @ 11:49:
[...]


Dat vind ik gek. De interface van je functie doet vermoeden dat je de strings moet vergelijken en dan is elke implementatie die daaraan voldoet geldig. Maar goed, dat zal wel weer zo'n gekke schoolopdracht zijn.

In dat geval raad ik je aan om niet de klinkers te verwijderen, maar om uit de eerste string een nieuwe string te construeren zonder klinkers. Je zult dan weer de string moeten doorlopen en alle niet-klinkers aan een tijdelijke string moeten toevoegen. Dit is makkelijker dan bij een eerste string beginnen en een voor een alle klinkers eruit te verwijderen.

dit lijkt me een goed plan

nu nog kijken hoe we moeten beginnen..gelukkig is de les nu af gelopen..dus nu even thuis zometeen verder kloten

[whoami]

Soultaker schreef op 06 januari 2003 @ 11:55:


Nee hoor. Bij mij is operator ostream::<< nog altijd overloaded voor character-pointers en geeft 'ie dus gewoon een mooie string weer (anders zou code als: cout << "blaat"; ook niet werken).

Voor pointers naar void of andere typen waar cout niets mee kan, wordt inderdaad wel de adreswaarde in de pointer weergegeven. Dit alles heeft echter meer te maken met de implementatie van ostream, dan met de werking van de taal C++ (al is C++ natuurlijk meer dan de taal alleen).

Hmmm... Ja, ok... My mistake.
_{is ook al weer een tijd geleden dat ik nog ge - C++ heb}

[Janoz]

Soultaker schreef op 06 January 2003 @ 11:49:
[...]


Dat vind ik gek. De interface van je functie doet vermoeden dat je de strings moet vergelijken en dan is elke implementatie die daaraan voldoet geldig. Maar goed, dat zal wel weer zo'n gekke schoolopdracht zijn.

In dat geval raad ik je aan om niet de klinkers te verwijderen, maar om uit de eerste string een nieuwe string te construeren zonder klinkers. Je zult dan weer de string moeten doorlopen en alle niet-klinkers aan een tijdelijke string moeten toevoegen. Dit is makkelijker dan bij een eerste string beginnen en een voor een alle klinkers eruit te verwijderen.

Het is nog veel simpeler.. Je HOEFT geen nieuwe string te maken aangezien je slechts 2 dingen hoeft te vergelijken. Je kunt gewoon kijken of het teken in de source string overeenkomt met het teken in de doelstring.

Ik heb een donkerbruin vermoden dat de TS slecht heeft opgelet.

[Soultaker]

Janoz schreef op 06 January 2003 @ 12:04:
Het is nog veel simpeler.. Je HOEFT geen nieuwe string te maken aangezien je slechts 2 dingen hoeft te vergelijken. Je kunt gewoon kijken of het teken in de source string overeenkomt met het teken in de doelstring.

Ik heb een donkerbruin vermoden dat de TS slecht heeft opgelet.

Dat was ook mijn suggestie (of ik begrijp de jouwe nu verkeerd), maar het antwoord van de topic starter daarop, was dat dat nu juist niet mocht. Ik vind dat ook gek, maar ik ken docenten en programmeervakken, en het zou zomaar kunnen.

[Verwijderd]

Wat de makkelijkste benadering is, is om de "find_first_of(..)" resp. "find_first_not_of(..)"interfaces van string te gebruiken. Maak trouwens gebruik van const pass-by-reference, i.p.v. pass-by-value dat scheelt een hoop stackruimte.

Een illustrerend voorbeeld dat gebruik maakt van find_first_not_of(...):

offtopic:
niet iedereen ziet de humor in van de opmerking dat je hier wel een voldoende mee kunt krijgen, maar de realiteit is dat het (een inmiddels verwijderd) cryptisch en incompleet voorbeeld was, zonder goed commentaar en dat je het zelf toch echt moet gaan begrijpen. In die zin kan de topicstarter er mijns insziens niet veel meer mee dan andere hints hiero.
Ik meen(de) ook vrij zeker te weten dat de opdracht is om een klinker-verwijderaar te maken en dit was enkel een util om dit algoritme te gaan testen, niet de oplossing van de opdracht. Zowiezo moest het hele algoritme herschreven worden, omdat de klinkers naar cout gestuurd moesten gaan worden, daar leent deze opzet zich niet voor.
Het was dus enkel een illustratie van "find_first_not_of(..)" die ook alleen als zodaig gebruikt kon worden, met een grappig bedoelde knipoog dat je wel een puntje zou kunnen scoren met "find_first_not_of"

C++:

    std::string::size_type idx = 0;
// sla klinkers over:
    idx = metKlinkers.find_first_not_of("AEIOUaeiou", idx);

[ Voor 98% gewijzigd door Verwijderd op 06-01-2003 13:56 . Reden: censuur? ]

[Soultaker]

Verwijderd schreef op 06 January 2003 @ 12:41:
Een mogelijke oplossing waarmee je zerer wel een voldoende kunt halen ;):

Het zou leuk zijn als de topic starter er zelf wat van opstak en na wat hulp van onze kant zelf met goede, werkende code kan komen. Zo maak je 't 'm wel erg makkelijk. Liever dus geen volledige code in huiswerk-topics, wat mij betreft.

[whoami]

Soultaker schreef op 06 januari 2003 @ 12:50:
[...]

Het zou leuk zijn als de topic starter er zelf wat van opstak en na wat hulp van onze kant zelf met goede, werkende code kan komen. Zo maak je 't 'm wel erg makkelijk. Liever dus geen volledige code in huiswerk-topics, wat mij betreft.

* whoami deelt deze mening

[MSalters]

* MSalters vindt dat ook de TS niet moet beginnen met code.

Wat probeer je eigenlijk te doen? Wat is je algoritme?

PS. Je kunt natuurlijk ook std::remove_if gebruiken. Dat is geen smokkelen, dat is serieus software ontwikkelen. Je probleem is namelijk klinkers uit een woord verwijderen.

[Soultaker]

MSalters schreef op 06 januari 2003 @ 13:21:
PS. Je kunt natuurlijk ook std::remove_if gebruiken. Dat is geen smokkelen, dat is serieus software ontwikkelen. Je probleem is namelijk klinkers uit een woord verwijderen.

Dat is het mooiste voorstel dat ik tot nu toe gezien heb! In code waarschijnlijk nog het korste ook en waarschijnlijk bij benadering het meest efficient. Dat illustreert maar weer hoe belangrijk het is om als C++ programmeur de STL te kennen.

[gitaarwerk]

tnx iedereen... hmzz. ik zit een beetje raar te doen met die dingen.. ik vind zelf ook dat ik het moet oplossen, anders word het erg makkelijk.

De "cout" hoeft helemaal niet inderdaad, dat klopt ook niet.. dat is eigenlijk een beetje om de functie te testen tegelijkertijd.. eigenlijk onzin, want dat kan daar helemaal niet.

Je mag dus gewoon geen strings vergelijken.. helaas...anders zou het een stukje makkelijker worden. Het is dus de bedoeling dat als je een willekeurig woord opgeeft, dat hij de medeklinkers in een andere string kan zetten.. zodat ie later pas vergeleken gaat worden door heel simpel met if string1 == string2

ik ga nog even zoeken

[gitaarwerk]

C++:

// hier start de functie
bool VerwijderdeKlinkers(string woordMetKlinkers, string woordZonderKlinkers)
{
    if ((woordMetKlinkers == "") && (woordZonderKlinkers == ""))
    {
        return true;
    }

        // tel woordMetKlinkers
        int woordLength = woordMetKlinkers.length();
        
        // initialeer string
        string woordZonderKlinkers2;
        
            // start loop
             for (int i = 0; i < (woordLength); i++)        
             {
    

                    // als medeklinker b wordt gevonden, sla em dan op.
                 if (woordMetKlinkers.find("b", i))
                    {
                //  cout << "Niet gevonden.";
                    }
                 else 
                    {
                        
                        woordZonderKlinkers2 += "b";
                        cout << woordZonderKlinkers2;
                        cout << i;
                    }


                 
            }

                // vergelijk zoord zonder klinkers.
                 if (woordZonderKlinkers == woordZonderKlinkers2)
                 {
                     return true;
                 }
}

ik heb nu dit gedaan,.. op aanraden van jullie hehe

hij heeft een probleem met de loop waar, hij herhaalt dus de niet i tot woordLength
best irritant

[ Voor 68% gewijzigd door gitaarwerk op 08-01-2003 11:08 ]

[mullah]

mijn eerste gok is dat je "kleiner of gelijk aan woordLength" bedoelt in je loop

dus : for (int i = 0; i <= (woordLength); i++)

(ik doe alleen niet zoveel c++ om te weten hoe loopjes precies tellen)

[Soultaker]

mullah schreef op 08 January 2003 @ 16:14:
mijn eerste gok is dat je "kleiner of gelijk aan woordLength" bedoelt in je loop

dus : for (int i = 0; i <= (woordLength); i++)

(ik doe alleen niet zoveel c++ om te weten hoe loopjes precies tellen)

Jij kunt maar beter niet naar het casino gaan.

De for-lus wordt doorlopen zolang de conditie (in jouw voorbeeld dus 'i <= (woordLength)') waar is. Als je een woord van 4 letters hebt, wordt de lus dus vijfmaal doorlopen, met i = 0, 1, 2, 3 én 4 (want 4 <= 4), en dat is dus niet de bedoeling.

[djluc]

Ik prgrammeer verder geen c ofzo, alleen php/js/html. Ik zou dit probleem oplosen door eerst alle letters apart in een array te zetten, en een array te maken met alle klinkers. Dan doorloop je gewoon de 1e array, iedere keer controleer je of de letter in de andere array staat, zoniet doe je string+= "de letter" .

[gitaarwerk]

jep...dat is dus op de pagina hiervoor gedaan.. hij had de rest van et script weggehaald zodat ik et nit kon zien meer.. niet erg hoor..maar ik ben TE n00b ervoor om die dingen te gaan gebruiken helaas..

ah voglends mij moet ik een " !" VOOR woordMetKlinkers in het if statement zetten zodat ie weer noraal gaat werken (ik heb et zelf niet bedacht )
klopt dit?? (ik kan op dit moment hier niet controlleren)

edit : gedaan nu :
kan het omdraaien, maar gebeurd het zelfde nog met dat uitroepteken.. et is wle logischer nu.. maar lost het probleem nog steeds niet op

[ Voor 53% gewijzigd door gitaarwerk op 08-01-2003 18:55 ]

[MSalters]

Waarom check je voor elke letter in het woord of de string "b"voorkomt???
Dus je checkt 10 keer of "b" voorkomt in bananenvla. Na 1 check weet je dat wel.
( Afgezien van de foute vorm van string::find() )

Als je de i-de letter van een string wilt hebben dan gebruik je in C++ operator[], dus gewoon "bananenvla "[ i ].

[gitaarwerk]

sorry MSalters.. die dingen hebben we gewoon nog niet geleerd.. ik wil het zelf graag begrijpen..

wat is de foute vorm dan van string.find() ??

[MSalters]

MSDN: std::string::find( char*, size_type offset ) zoekt vanaf positie 'offset' tot het einde naar de string "b". Eigenlijk wil je naar het enkele karakter 'b' zoeken, en geen subranges gebruiken. Bovendien moet je checken of het karakter dan gevonden is
Dwz.

code:

woordMetKlinkers.find( 'b' ) != std::string::npos;

Daar heb je dus geen loop voor nodig, er komt geen 'i' in voor

[ Voor 17% gewijzigd door MSalters op 09-01-2003 09:39 . Reden: URL ]

[Verwijderd]

Om te achterhalen of een string leeg is, kun je trouwens veel beter "empty()" gebruiken, dus:

C++:

if ( woordMetKlinkers.emty() && woordZonderKlinkers.empty() )

En om bijvoorbeeld alle medeklinkers te vinden, zou je find_first_of kunnen gebruiken met de hele lijst aan karakters (uppercase/lowercase) die je wilt vinden.

En in jouw voorbeeld vind je de b wel heel vaak als er een b enkel aan het einde van de string staat, je moet "i" ook updaten door de return-value van find/find_first_of. Deze "i" moet je dan wel type "std::string::size_type" meegeven en laten controleren op < std::string::npos, i.p.v. woordLength)

(En vergeet niet find/find_first_of/.. te checken op npos, zoals MSalter ook al aangaf.)