[C] *char array als arg. aan functie

[Zynth]

ik zit met een waarschijnlijk klassiek pointer probleem.
xal eerst ff vertellen wat ik wil, en daarna wat ik al geprobeerd heb.

De bedoeling;
ik declareer in een functie een char-array.
vervolgens roep ik een andere functie aan, met
die char-array als argument, omdat het de bedoeling
is dat die functie de letterlijke inhoud van de array kan veranderen.

nou probeer ik dat zo:

code:

function begin(){
  void getArgument(char buffer[], char *strArgument[]);
  char *strArgument[80];
  char buffer[10];

  //blaat
  getArgument(buffer,strArgument);
  //nu zou die functie dus mijn lokale strArgument veranderd moeten kunnen hebben
}

dit is ongeveer de enige manier waarop ik niet al bij het compilen een fout krijg.
maar als ik nu in getArgument de strArgument probeer te bewerken,
gaat het programma hangen op die functie...
punt 1 is het al mega-irritant dat ik op deze manier in begin() en in getArgument() niet de functie memset en strncpy kan gebruiken op mijn char-array,
maar ik krijg er ook uberhaupt niks normaal in. hoe kan ik dat doen??

[Zynth]

als ik het trouwens op een andere manier zou willen oplossen,
door getArgument() een char-array te laten returnen:
strArgument=getArgument(buffer);

hoe moet ik dan die functie declareren?
ik krijg namelijk steeds errors bij die declaratie,
en ik kan nergens vinden hoe ik een functie een array kan laten returnen.

char[] getArgument(char buffer[]);
geeft fouten op die [] achter char...

[whoami]

Een arrray pas je zowiezo al by reference.

Als je je code zo schrijft:

code:

void getArgument (char buffer[], char strArg[]);

int main()
{
    char arr1[10], arr2[10];

    getArgument(arr1, arr2);

    return 0;
}

void getArgument( char buffer[10], char argument[10])
{
}

Dan zijn de wijzigingen die je in de arrays buffer en argument in de getArgument functie gedaan hebt, ook zichtbaar in de main, aangezien arrays per definitie by reference worden doorgegeven en niet by value.

Trouwens, wat staat die function daar te doen ? Dat is geen geldig C++ keyword....
Als je een functie wilt hebben die een waarde returned, dan moet je dat als volgt schrijven:

code:

int ReturnAnIntegerFunction()
{
     return 1;
}

Als je een functie wilt, die een char array moet returnen declareer je ze zo:

code:

char* returnCharArrayFunction();

[ Voor 8% gewijzigd door whoami op 08-06-2003 11:19 ]

[Zynth]

kijk,daar heb ik wat aan
thnx!

[.oisyn]

whoami schreef op 08 June 2003 @ 11:17:
Trouwens, wat staat die function daar te doen ? Dat is geen geldig C++ keyword....[/code]

het is ten eerste C en geen C++
maar:

C:

typedef void (*function) ();

function begin ()
{
    // retourneer een pointer naar een functie hier
}

Het lijkt mij dus een perfect legale constructie, mits function van tevoren gedefinieerd is

Zynth: het is trouwens beter om arrays die je niet aanpast als const te declareren. Dit is bij het buffer argument bijvoorbeeld het geval. Definieer de functie zo:

C:

void getArgument (const char buffer[], char * strArgument[]);

Overigens, als je een array wilt retourneren, moet je goed letten op geheugenallocatie. Je kunt namelijk geen locale array teruggeven, en als je geheugen alloceert dan moet de caller dat weer opruimen. Beter en makkelijker is dus gewoon de oplossing waar je nu voor hebt gekozen, dit is de standaard manier in vele API's. Maar je moet eigenlijk wel een extra parameter meegeven dat aangeeft hoe groot de buffer is, zodat bufferoverflows niet kunnen optreden

[VisionMaster]

.oisyn schreef op 08 juni 2003 @ 13:44:
[...]
Overigens, als je een array wilt retourneren, moet je goed letten op geheugenallocatie. Je kunt namelijk geen locale array teruggeven, en als je geheugen alloceert dan moet de caller dat weer opruimen. Beter en makkelijker is dus gewoon de oplossing waar je nu voor hebt gekozen, dit is de standaard manier in vele API's. Maar je moet eigenlijk wel een extra parameter meegeven dat aangeeft hoe groot de buffer is, zodat bufferoverflows niet kunnen optreden

Je kan een pointer retourneren naar een lokaal gecreeerd 'iets' (ik wou bijna zeggen object) en dan een declareren als static, dan wordt het niet weggeflikkerd (en verloren) en kan je er altijd naar blijven pointen.

edit: trouwens waarom gebuik je char bla[] en niet char * bla;
Dan kan je makkelijker met de sterre-tjes tellen (vind ik makkelijker om mijn overzicht weer terug in mijn eigen geheugen -MyBrain();- te krijgen).

[ Voor 16% gewijzigd door VisionMaster op 08-06-2003 13:53 ]

[.oisyn]

VisionMaster schreef op 08 June 2003 @ 13:51:
Je kan een pointer retourneren naar een lokaal gecreeerd 'iets' (ik wou bijna zeggen object) en dan een declareren als static, dan wordt het niet weggeflikkerd (en verloren) en kan je er altijd naar blijven pointen.

en dan is het dus sowieso al niet meer lokaal (ja, de toegang tot die var is lokaal, maar de variabele zelf is globaal), en het is bovendien niet threadsafe. Ook zit je met een vaste array-grootte (die misschien wel te klein is), en je moet 'm groot genoeg declareren, waardoor het gebruikte geheugen van je programma toeneemt

[curry684]

whoami schreef op 08 June 2003 @ 11:17:
Een arrray pas je zowiezo al by reference.

Da's onzin

Een array pass je over het algemeen by-pointer, en eventueel ook by reference.

Vergelijk:

C++:

void Function(char* p_ByPointer);
void Function(char p_ByPointer[]);
void Function(char* &p_PointerByReference);   // Dit zijn de leuke  :)

Die laatste constructie gebruik je als je wilt dat de functie een pointer in een by-reference meegegeven locatie opslaat.

[ Voor 1% gewijzigd door curry684 op 08-06-2003 15:42 . Reden: Code=c++ ja voor de mierenneukers :) ]

[.oisyn]

En dan is er nog

C++:

void function (char (&byReference)[100]);

wat een referentie naar een array van 100 chars is Op deze manier kun je dus verplichten dat de caller altijd een array van 100 chars meegeeft. Zo niet, dan krijg je een compile error. Nadeel is echter wel dat grotere arrays ook niet geaccepteerd worden... maar daar is wel wat leuks op te verzinnen:

C++:

void function (char (&buf)[100]);

template <int N> void function (char (&buf)[N])
{
    char array_should_be_at_least_100_chars[(N >= 100) ? 1 : -1];
    function (reinterpret_cast<char (&)[100]> (buf));
}

wat werkt bij arrays >= 100 elementen, maar een compile error geeft als het kleiner is dan 100


Maar goed, dit was een C topic, geen C++ topic

[ Voor 4% gewijzigd door .oisyn op 08-06-2003 17:46 ]

[Zynth]

nou, thnx allemaal
maar nou heb ik nog een vraag; ongeveer hetzelfde princiepe, alleen nou over structs.
Ik wil namelijk bepaalde informatie in een struct bijhouden, zodat ik aan elke functie maar 1 argument hoef meer te geven met een struct in plaats van tig variabelen.
De functies moeten echter wel in staat zijn de originele structwaarden te veranderen.

ik heb een struct gemaakt als volgt, bovenin het document (bij de glob. vars)

code:

typedef struct {
   char ip[15];
   int port;
   int socket;
} clientInfo;

//vervolgens heb ik in mijn main staan:
clientInfo client;

//het vullen met:
client->socket=sock

maar dat vullen gaat fout; mag niet...

de functies waaraan ik de struct wil meegeven maak ik als volgt aan:
void functietje(clientInfo *client);

en de functie zelf:
void functietje(clientInfo *client){
//dit mag dan netjes
client->port=10;
}

deze funtie roep ik dan vanuit de main aan als:
functietje(*client);
maar ik krijg het dus in de main zélf, niét voor elkaar om een structwaarde
te veranderen...

hoe moet ik dit überhaupt aanpakken; een struct hebben in mijn programma,
waarin functies wijzigingen kunnen aanbrengen?

[ Voor 9% gewijzigd door Zynth op 08-06-2003 22:48 ]

[.oisyn]

Lees een freakin' manual

Als het geen pointer is: gebruik een .
als het wel een pointer is: gebruik ->

[Sponz]

In C passeer je parameters altijd by value, nooit by reference, alhoewel het er sterk op lijkt en het effect ook min of meer hetzelfde is, maar strikt genomen is het by value.

[curry684]

Sponz schreef op 09 juni 2003 @ 02:00:
In C passeer je parameters altijd by value, nooit by reference, alhoewel het er sterk op lijkt en het effect ook min of meer hetzelfde is, maar strikt genomen is het by value.

Of by-pointer, wat iets heel anders is. Maar zoals oisyn al zegt: een leuk beginnersboek legt dit soort dingen heel duidelijk uit, en het is niet de bedoeling dat we in dit topic nu alle beginnersprobleempjes met pointers en references nog een keer aan gaan halen.