[C] functie aanroepen met pointer & uitvoer pointer

[Xorgye]

Ik programmeer al tijden, maar wil toch maar eens wat 'cleaner' gaan programmeren.
Dit houd in dat ik een functie aan wil roepen en van de functie een waarde terug wil krijgen zonder dat de functie in een globale variabele zijn antwoord stopt.

Aangezien ik met C werk in de Dev-C++ compiler en dus ook wat C++ mag gebruiken, dacht ik dat het gebruik van een pointer wel handig zou zijn. Je stopt er een pointer in en die krijg je terug, nu naar de gemodificeerde informatie.

Nu de vraag: ik wilde graag dat een tekenreeks bewerkt zou worden, en ik aan de functie niet een pointer maar een characterreeks omgezet naar pointer geef.

Ik ben absoluut niet bekend met hoe je pointers moet gebruiken en hoe je een char naar een pointer mag overzetten. Zelf dacht ik hier aan, maar dat werkt dus niet:

C:

int main()
{
     char tekenreeks[5]; 
     pointernaarreeks = lowercase(&tekenreeks);
}

long lowercase(long tekenreeks)
{
     long pointernaarresultaat;
     //bewerk de tekenreeks
     return pointernaarresultaat;
}

Het maakt trouwens niet uit dat ik een pointer terug krijg (hoewel char mischien ook handig is, maar dit heb ik ook voor andere dingen nodig)

[twanvl]

Een long is geen pointer. In C hebben pointers een type dat aangeeft waarnaar gewezen wordt. In jouw geval is dat een char** (pointer-naar pointer-naar/array-van char). Die tweede laag heb je in dit voorbeeld zelfs niet echt nodig, omdat je niet de plaats in het geheugen van de string (de char*) hoeft te veranderen. Een tekenreeks is trouwens geen 'char', maar 'char[]' of 'char*'.
Jou voorbeeld kan je op twee manieren aanpakken:

1. Je bewerkt de inkommende tekenreeks zodanig dat ie lowercase wordt.
2. Je maakt een kopie van de tekenreeks, en maakt die kopie lowercase.

De eerste oplossing heeft hier de voorkeur, omdat je in het tweede geval heel erg op moet passen wij de nieuwe tekenreeks alloceert.

[joca]

Als je een functie met een pointer wilt aanroepen moet je wel zorgen dat je functie weet dat hij een pointer mee krijgt.

Je hoeft overigens geen pointer terug te geven tenzij je de uitkomst in een ander array zet. Met een pointer geef je het adres van je functie mee en kan je de data in je tekenreeks array aanpassen.

Wil je wel een pointer teruggegeven zie dan voorbeel 2.

C:

/*prototyping*/
void lowercase(char * )

int main()
{
     char tekenreeks[5]; 
     lowercase(&tekenreeks);
}

void lowercase(char * tekenreeks)
{
     //bewerk de tekenreeks   
}

C:

/*prototyping*/
unsigned char * lowercase(char * tekenreeks)

int main()
{
     char tekenreeks[5]; 
     unsigned char * pointernaarreeks;
     pointernaarreeks = lowercase(&tekenreeks);
}

unsigned char * lowercase(char * tekenreeks)
{
     char result[5];
     //bewerk de tekenreeks
     return &result;
}

[Verwijderd]

&var is het adres van een variabele, aangezien C maar twee variabelen kent (pointers en getallen) is een array een pointer naar een aantal gelijke elementen achter elkaar.
char string[5];
betekent dus dat string al een pointer is (namelijk een pointer naar het eerste element uit de array van chars).
Speciaal voor pointers heeft C het sterretje *. Als je een pointer naar een char element (of een reeks van die dingen) wilt maken gebruik je daarvoor char*.
char* pointernaarreeks;
maakt dus een pointer die verwijst naar een char element.

C:

int main() 
{ 
     char tekenreeks[5];
     char* pointernaarreeks;
     pointernaarreeks = lowercase(tekenreeks);
} 

char* lowercase(long tekenreeks) 
{ 
     char* pointernaarresultaat; 
     //bewerk de tekenreeks 
     return pointernaarresultaat; 
}

Als je alleen de individuele letters veranderd zal je dus de string als geheel niet veranderen, dat betekent dat pointernaarreeks == pointernaarresultaat == tekenreeks.
In dit geval hoef je dus zelfs niets terug te geven, aangezien je functie direct de gegevens uit je main() aanpast!

[Xorgye]

Sorry, dat ik het prototyping was vergeten in te voegen
De compiler wijst me er elke keer op... en vergeet 't nog steeds...

Maar ik heb nu voldoende informatie.
Ik hoeft inderdaad geen pointer terug te geven omdat de data die in de lokale reeks staat al verandert is na de aanroep van de functie. Handig, zo'n pointer

[Xorgye]

Het resultaat is geworden:

C:

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

#define LOWERCASE                   1

bool bewerkreeks(int opdracht, char * tekenreeks);


int main()
{
    char naam[45];
    strcpy(naam, "XorgYe1234");
     
    printf(" naam [%s] word ", naam);
    
    bewerkreeks(LOWERCASE, naam);
    
    printf("naam [%s]\n", naam);

    
    char str[80];
    scanf("%s",str);
}


bool bewerkreeks(int opdracht, char * tekenreeks)
{
     switch(opdracht)
     {
          case LOWERCASE:
          {
               int x = 0;
               while(tekenreeks[x] != 0)
               {
                    if(tekenreeks[x] >= 'A' && tekenreeks[x] <= 'Z')
                    {
                         tekenreeks[x] = tekenreeks[x] - ('A' - 'a');
                    }
                    x++;
               }
               return true;
          } break;
          default: break;
     }
     return false;
}

*Deze post is gemodified... omdat ik hiervoor een super domme opmerking maakte bij de code*

[ Voor 59% gewijzigd door Xorgye op 14-05-2005 16:27 . Reden: Mensen... ik zit er niet met me hoofd bij. Ik had deze post eerder gepost met de gedachte dat hij niet werkte... na de 2e keer compilen bleek het tegendeel... ]

[Ivo]

//gaat het werken als ik hier als 2e parameter gewoon 'naam' opgeef? Moet
//ik die niet omzetten naar pointer?

Dat gaat goed zo. Naam van array is hetzelfde als pointer naar eerste element van dat array. Dus:

array = &array[0]

[ Voor 5% gewijzigd door Ivo op 14-05-2005 16:24 ]

[MSalters]

Werkt niet voor non-ASCII. Probeer tolower( ) eens.

[MrBucket]

Joca schreef op zaterdag 14 mei 2005 @ 15:54:

C:

unsigned char * lowercase(char * tekenreeks)
{
     char result[5];
     //bewerk de tekenreeks
     return &result;
}

Dit wil je niet doen (alhoewel het in veel gevallen wel zal lijken te werken - niet in alle gevallen).
Je retourneert hier nl. het adres van een lokale variabele 'result'. Officieel bestaat, na beeindiging van de functie lowercase(), deze variabele niet meer en dus verwijst de geretourneerde pointer naar een stuk vrijgegeven geheugen (!!!).
Bovendien zou je "return result" (zonder '&') moeten schrijven. De expressie 'result' is nl. een pointer naar het 0e element van de char array.

[joca]

Ja klopt idd, even niet over nagedacht. Hetzelfde geldt eigenlijk ook voor z'n huidige oplossing met de aanroep vanuit main, daar wordt ook een lokale variabele gebruikt.

Voor de return was idd &result[0] of result de oplossing geweest.