🚀 go-pugleaf

Skender wrote:
> Ik heb een programmatje geschreven dat postcodes zoekt als oefening op
> strings, maar het werkt niet zoals het zou moeten.
> 
> Ik heb een bestand "belgie" dat postcodes bevat.  Een lijn per gemeente,
> zoals bijvoorbeeld
> 9000Gent
> 9840De Pinte
> 
> De postcodes staan op http://vrijzijn.be/belgie
> M'n code:
> 
> char *strlwr (char* tekst){
>   int aantal=strlen(tekst);
>   char* res = new char[aantal];
>   for(int i=0; i<aantal; i++)
>     res[i]=tolower(tekst[i]);
>   return res;
> }
> 

Ik heb je probleem kunnen simuleren met versie 3.2.2.
Je doet hier een *new*, maar er gebeurt nooit een *delete* !
Het kan zijn dat vorige versie van gcc hier geen probleem mee hadden, 
maar het is niet erg proper.

Pas je functie aan :

char *strlwr (char *tekst) {
   int aantal=strlen (tekst);
   //char* res = new char[aantal];
   for (int i = 0; i < aantal; i++)
     tekst[i] = tolower(tekst [i]);
     // res[i] = tolower(tekst [i]);
   return tekst;
   // return res;
}

en je hebt geen problemen meer.
Als 'tekst' niet mag wijzigen, alloceer met new dan een variable in main 
(of in naamBevat), en pas er nadien een delete op toe.

--
  Kristoffel

Kristoffel wrote:
> Skender wrote:
> 
>> Ik heb een programmatje geschreven dat postcodes zoekt als oefening op
>> strings, maar het werkt niet zoals het zou moeten.
>>
>> Ik heb een bestand "belgie" dat postcodes bevat.  Een lijn per gemeente,
>> zoals bijvoorbeeld
>> 9000Gent
>> 9840De Pinte
>>
>> De postcodes staan op http://vrijzijn.be/belgie
>> M'n code:
>>
>> char *strlwr (char* tekst){
>>   int aantal=strlen(tekst);
>>   char* res = new char[aantal];
>>   for(int i=0; i<aantal; i++)
>>     res[i]=tolower(tekst[i]);
>>   return res;
>> }
>>
> 
> Ik heb je probleem kunnen simuleren met versie 3.2.2.
> Je doet hier een *new*, maar er gebeurt nooit een *delete* !
> Het kan zijn dat vorige versie van gcc hier geen probleem mee hadden, 
> maar het is niet erg proper.
> 
> Pas je functie aan :
> 
> char *strlwr (char *tekst) {
>   int aantal=strlen (tekst);
>   //char* res = new char[aantal];
>   for (int i = 0; i < aantal; i++)
>     tekst[i] = tolower(tekst [i]);
>     // res[i] = tolower(tekst [i]);
>   return tekst;
>   // return res;
> }
> 
> en je hebt geen problemen meer.
> Als 'tekst' niet mag wijzigen, alloceer met new dan een variable in main 
> (of in naamBevat), en pas er nadien een delete op toe.
> 
> -- 
>  Kristoffel

Best ook Gemeente::naamBevat aanpassen, anders verander je het attribuut 
gemeente.naam in kleine letters!

bool Gemeente::naamBevat (char *p_naam) {
   char *res = new char [strlen (getNaam ())+1];
   strcpy (res, getNaam ());
   bool ret = strstr (strlwr(res), strlwr (p_naam)) != 0;
   delete res;
   return ret;
}

--
  Kristoffel

Kristoffel wrote:

(snip)

> Ik heb je probleem kunnen simuleren met versie 3.2.2.
> Je doet hier een *new*, maar er gebeurt nooit een *delete* !
> Het kan zijn dat vorige versie van gcc hier geen probleem mee hadden,
> maar het is niet erg proper.

AFAIK is het niet deleten van genewde blokken niet ongedefinieerd, en mag
dus niet de door de OP vermelde problemen opleveren (ervan uitgaande dat de
code voor de rest correct is, niet nagekeken en niet bepaald in de stemming
ervoor *geeuw* (-; ).

-- 
Nicolas Barbier
Protecting innovation against patent inflation <url:http://swpat.ffii.org/>

On 19/06/2004, Skender wrote:

<knip>

> void Gemeente::setNaam(char* invoer){
>   naam = new char [strlen(invoer)];
>   strcpy(naam,invoer);
> }

<knip>

Dit is het eerste wat ik opmerkte. Je maakt een buffer aan met lengte 
van de string, maar je vergeet dat er nog een NULL achter moet komen. 
De strcpy zet die NULL dus buiten de buffer. Het gevolg hiervan hangt 
af van de compiler. Mijn ervaring hiermee is dat het programma niet 
werkt zoals je verwacht en meestal op een totaal andere plaats crasht. 
Voor de rest zijn er redelijk wat memory leaks in de code, maar die 
be�nvloeden niet direct de flow van het programma.
Waarom werk je niet met std::string in plaats van char arrays?

Haplo

-- 
There are two major products that come out of Berkeley: LSD and BSD 
UNIX.  We don't believe this to be a coincidence.

Haplo wrote:
> Dit is het eerste wat ik opmerkte. Je maakt een buffer aan met lengte
> van de string, maar je vergeet dat er nog een NULL achter moet komen.
[KNIP]

Dat was inderdaad de fout.��Stom�van�mij.

> Waarom werk je niet met std::string in plaats van char arrays?

Omdat ik dat niet ken.��Ik�weet�alleen�wat�ik�op�school�heb�geleerd�(en�dat
is niet veel) en wat ik via Google tegenkom (al is dat niet altijd juist). 
Ik ben wel van plan om mij tijdens de vakantie eens op "Thinking in C++" te
storten.

Skender

Kristoffel wrote:

>> Ik heb je probleem kunnen simuleren met versie 3.2.2.
>> Je doet hier een *new*, maar er gebeurt nooit een *delete* !
>> Het kan zijn dat vorige versie van gcc hier geen probleem mee hadden,
>> maar het is niet erg proper.

Proper is het inderdaad niet, maar in de functie strlwr() kan ik geen delete
gebruiken.  Die functie blijft van de oorspronkelijke array af, en maakt
een nieuwe die het als resultaat terug geeft.  Die nieuwe mag niet
verwijderd worden, want dan hen ik niets meer om als resultaat terug te
geven ;-)

Ik heb wel een destructor gemaakt voor de klasse Gemeente.  Dit is de eerste
destructor die ik schrijf.  Ik vermoed dat dat er ongeveer zo moet uit
zien:

Gemeente::~Gemeente(){
  delete [] naam;
}

Ik heb m'n code nog eens gelezen, maar ik zie nergens een plaats waar een
delete nodig is.

Skender

Haplo wrote:

Weis & Hickmann?

-- 
John                               MexIT: http://johnbokma.com/mexit/
                            personal page:       http://johnbokma.com/
    Experienced Perl programmer available:     http://castleamber.com/
             Happy Customers: http://castleamber.com/testimonials.html

Skender wrote:
> Kristoffel wrote:
> 
> 
> 
> Ik heb wel een destructor gemaakt voor de klasse Gemeente.  Dit is de eerste
> destructor die ik schrijf.  Ik vermoed dat dat er ongeveer zo moet uit
> zien:
> 
> Gemeente::~Gemeente(){
>   delete [] naam;
> }

delete naam;

> 
> Ik heb m'n code nog eens gelezen, maar ik zie nergens een plaats waar een
> delete nodig is.
> 

Wat het attribuut 'naam' betreft: je hebt het niet nodig omdat uw 
gemeente objecten verwijderd worden bij het verlaten van het programma. 
Uw destructor is wel aan te bevelen.

Ik blijf erbij dat het in strlwr wel een probleem geeft.

Waarom bewaar je de gemeentenaam niet in uppercase ?

--
  Kristoffel

Skender wrote:

>> Waarom werk je niet met std::string in plaats van char arrays?
> 
> Omdat ik dat niet ken.

Begin dan dringend te zoeken naar introducties over de STL (standard
template library) want anders ga je alles zelf doen... 
Gewoon uit interesse: welke datastructuren gebruik je dan nu?
-- 
"May the source be with you"

"Kristoffel" <kdg1955@yahoo.com> wrote in message
news:XouBc.161867$UL1.8209503@phobos.telenet-ops.be...
> Skender wrote:
> > Gemeente::~Gemeente(){
> >   delete [] naam;
> > }
>
> delete naam;
naam was aangemaakt via new char[], en moet dus wel via delete[] verwijderd
worden. Hoewel gewoon delete in de praktijk wel zal lijken te werken, mag
het niet en gaat het zeker mis op het moment dat je een array van objecten
met destructors verwijderd.

Gewoon zo veel mogelijk std::string en verder smart pointers gebruiken, dat
scheelt een hoop moeite.

Aquila wrote:
> Begin dan dringend te zoeken naar introducties over de STL (standard
> template library) want anders ga je alles zelf doen...
> Gewoon uit interesse: welke datastructuren gebruik je dan nu?

Die die ik zelf schrijf ;-)
En verder gebruik ik enkel de gewone variablen zoals bool, char, int of
double.

Intussen heb ik via Google dit gevonden:
http://www.infosys.tuwien.ac.at/Research/Component/tutorial/prwmain.htm
The Standard Template Library Tutorial

Ik zal me daar eens mee bezig houden.

Skender

Arnold Hendriks wrote:

> 
> "Kristoffel" <kdg1955@yahoo.com> wrote in message
> news:XouBc.161867$UL1.8209503@phobos.telenet-ops.be...
>> Skender wrote:
>> > Gemeente::~Gemeente(){
>> >   delete [] naam;
>> > }
>>
>> delete naam;
> naam was aangemaakt via new char[], en moet dus wel via delete[]
> verwijderd worden. 

Wanneer moet ik eigenlijk een string deleten?  In deze functie bijvoorbeeld
worden twee strings aangemaakt, maar ik kan ze niet deleten, want ik heb er
geen pointer naar.

bool Gemeente::naamBevat(char* gezocht){
  return strstr(getNaamKlein(),strlwr(gezocht)) != 0;
}

Moet ik dat dan vervangen door dit?

bool Gemeente::naamBevat(char* gezocht){
  char* naamKlein = getNaamKlein();
  char* gezochtKlein = strlwr(gezocht);
  bool res = strstr(naamKlein,gezochtKlein) != 0;
  delete [] naamKlein;
  delete [] gezochtKlein;
  return res;
}

Skender

"Skender" <Skender@GeenSpamAUB.VrijZijn.be> wrote in message
news:NhDBc.162226$LL2.8273027@phobos.telenet-ops.be...

> > naam was aangemaakt via new char[], en moet dus wel via delete[]
> > verwijderd worden.
>
> Wanneer moet ik eigenlijk een string deleten?
Je moet niets. Je mag hem deleten zodra je hem niet meer nodig hebt.

> In deze functie bijvoorbeeld
> worden twee strings aangemaakt, maar ik kan ze niet deleten, want ik heb
er
> geen pointer naar.
>
> bool Gemeente::naamBevat(char* gezocht){
>   return strstr(getNaamKlein(),strlwr(gezocht)) != 0;
> }
>
> Moet ik dat dan vervangen door dit?
>
> bool Gemeente::naamBevat(char* gezocht){
>   char* naamKlein = getNaamKlein();

>   char* gezochtKlein = strlwr(gezocht);
>   bool res = strstr(naamKlein,gezochtKlein) != 0;
>   delete [] naamKlein;

Alleen als getNaamKlein() een new[] heeft uitgevoerd


>   delete [] gezochtKlein;
strlwr() is geen standaard C++ functie. De eerste strlwr die ik op google
zie geeft dezelfde waarde terug als die je erin stopt, maw: hij verandert de
string die je doorgaf aan de functie. Als dat ook jouw strlwr() is, dan heb
je bij deze niet alleen 'gezochtKlein' verwijderd maar ook 'gezocht'. Ik
denk niet dat dat je bedoeling was, want een tweede aanroep van naamBevat
voor een ander object, maar met dezelfde string pointer, zou dan crashen.

In dat geval had de compiler trouwens de fout zelf ook opgespoord als je hem
had aangegeven dat het niet je bedoeling was 'gezocht' zelf te wijzigen
(zoals waarschijnlijk je intentie was:)

bool Gemeente::naamBevat(char const * gezocht)

Je zou het ook met std::string kunnen oplossen, op voorwaarde dat
getNaamKlein ook een std::string teruggeeft:

using namespace std;
bool Gemeente::naamBevat(string const &gezocht){
  string naamKlein = getNaamKlein();
  string gezochtKlein = gezocht;
  transform(gezochtKlein.begin(), gezochtKlein.eind(), gezochtKlein.begin(),
tolower);
  return naamKlein.find(gezochtKlein) != string::npos;
}

Dan ben je helemaal van de deletes af. string regelt dat allemaal zelf.
Nadeel is dat de code enigszins onnatuurlijk kan overkomen, als je nog niet
echt gewend bent aan de C++ uitbreidingen op de C libraries.

Arnold Hendriks wrote:
> Alleen als getNaamKlein() een new[] heeft uitgevoerd

Dat doet hij inderdaad.

>>   delete [] gezochtKlein;
> strlwr() is geen standaard C++ functie. De eerste strlwr die ik op google
> zie geeft dezelfde waarde terug als die je erin stopt, maw: hij verandert
> de string die je doorgaf aan de functie. Als dat ook jouw strlwr() is, dan
> heb je bij deze niet alleen 'gezochtKlein' verwijderd maar ook 'gezocht'.
> Ik denk niet dat dat je bedoeling was, want een tweede aanroep van
> naamBevat voor een ander object, maar met dezelfde string pointer, zou dan
> crashen.

Toen ik merkte dat strlwr() inderdaad niet bestond, heb ik hem zelf
geschreven.  Mijn versie maakt een nieuwe tabel met new []
Het was waarschijnlijk beter geweest als ik hem een andere naam gegeven had.

[KNIP]
> Je zou het ook met std::string kunnen oplossen, op voorwaarde dat
> getNaamKlein ook een std::string teruggeeft:
[KNIP]

Ik heb vanmiddag m'n laatste examen gehad, en ga me deze week wat met C++
bezig houden.  Ik ben intussen 2 hoofdstukken ver in "Thinking in C++" van
Bruce Eckel, en heb m'n eerste kennismaking met std::string achter de rug. 
Als ik wat verder gevorderd ben ik dat boek, herschrijf ik m'n postcode
programmatje wel eens.

Bedankt voor de hulp,
Skender

On 20/06/2004, John Bokma wrote:

> Weis & Hickmann?

Inderdaad.

-- 
"To be or nut^H^H^H -- sh^Gt, how do I delete..^D^D^D Oh No Oh NO^D^D^D 
-- How  do I get out of this thing anyway (mumble mumble) Bus error 
(core dumped)

Haplo wrote:

> On 20/06/2004, John Bokma wrote:
> 
>> Weis & Hickmann?
> 
> Inderdaad.

Ooit gebruikt als nick, heel lang geleden :-D.

-- 
John                               MexIT: http://johnbokma.com/mexit/
                            personal page:       http://johnbokma.com/
    Experienced Perl programmer available:     http://castleamber.com/
             Happy Customers: http://castleamber.com/testimonials.html

> char *strlwr (char* tekst){
>   int aantal=strlen(tekst);
>   char* res = new char[aantal];
>   for(int i=0; i<aantal; i++)
>     res[i]=tolower(tekst[i]);
>   return res;
> }

Buiten het feit dat je hier een memory leak hebt (new maar nergens 
delete), vergeet je ook je resultaat string "res" te terminaten. Een 
"c" string moet altijd eindigen met een '\0' karakter. Hierdoor zal je 
programma "soms" werken en "soms" niet, afhankelijk van er toevallig in 
je geheugen zat.

Dus je functie zou er als volgt moeten uitzien:

char *strlwr (char* tekst)
{
	int aantal=strlen(tekst);
	char* res = new char[aantal + 1]; // 1tje meer alloceren
	for(int i=0; i<aantal; i++)
		res[i]=tolower(tekst[i]);
	res[i] = '\0'; // string terminaten!
  	return res;
}

En uiteraard moet "res" ergens met een "delete[]" terug vrijgegeven 
worden door de code die deze functie oproept...

Kurt