globales Array - Funktionen - Zeigerarithmetik

[c_testDummy (Gast)]

Moin,

Ich programmiere ( oder versuche es ) gerade in C und nun habe ich ein 
paar Fragen zur Zeigerarithmetik ;)

und zwar möchte in ein globales Array in verschieden funktionen 
verarbeiten bzw füllen.
Das Array soll in 1-X mal befüllt werden mit Werten und nach jedem 
Funktionsaufruf soll sich das Programm merken bis wohin er das globale 
Array befüllt hat um es bei einem anderen Funktionsaufruf wieder weiter 
ab dort zu befüllen

int array[500]

int funktion1 ( int *arrayptr )
{
// check bis wohin gefüllt wurde
// array weiter mit Werten füllen bis array[x]
// wenn array voll: return -1;
}

int funktion2 ( int *arrayptr )
{
// check bis wohin gefüllt wurde
// array weiter mit Werten füllen bis array[x]
// wenn array voll: return -1;
}

void main ()
{
int returnWert = 0;

while (returnWert>=0)
{
returnWert = funktion1(array);
returnWert = funktion2(array);
.
.
.
}
}

Ich hoffe ich konnte mich auf die schnelle verständlich ausdrücken, 
meine Frage dazu jetzt : merkt sich der Pointer in der Funktion die 
stelle an der er stand ? bzw gibt es eine geschicktere Möglichkeit um 
ein globales Array mit verschiedenen Funktionen nach und nach zu füllen 
?

grüße

[Rene H. (Gast)]

Hmm, wenn ich Dich richtig verstanden habe, brauchst Du dazu einen 
doppelpointer.

int array[500]

int funktion1 ( int **arrayptr )
{
// check bis wohin gefllt wurde
// array weiter mit Werten fllen bis array[x]
// wenn array voll: return -1;
}

int funktion2 ( int **arrayptr )
{
// check bis wohin gefllt wurde
// array weiter mit Werten fllen bis array[x]
// wenn array voll: return -1;
}

void main ()
{
int returnWert = 0;

while (returnWert>=0)
{
   int** arraypointer = &array:

returnWert = funktion1(arraypointer);
returnWert = funktion2(arraypointer);
.
.
.
}
}

Grüsse,
René

[c_testDummy (Gast)]

hmm was genau bewirkt das ?

Ich übergebe doch nur eine Speicheraddresse damit oder ? Nach der 
Funktion steht der Pointer in Main doch immernoch an der gleichen Stelle 
wie beim Funktionsaufruf da er nicht global ist.

Müsste ich vlt einen globalen Pointer erzeugen um mir die aktuelle 
speicherstelle zu merken und in den funktionen Referenziere ich einfach 
auf diesen Pointer ? Wobei ich eigentlich nur das Array global halten 
wollte.

[Rene H. (Gast)]

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>


uint8_t array[500];

void mach_was(uint8_t** ptr)
{
   uint8_t i;

   for (i = 0; i < 10; i++, (*ptr)++)
      (*ptr)[i] = i;
}


int
main (int argc, char *argv[])
{
  uint8_t* arrayptr = array;

  fprintf(stdout, "ptr: %x\n", arrayptr);

  mach_was (&arrayptr);

  fprintf(stdout, "ptr: %x\n", arrayptr);

  return (0);
}

Versuch das mal und studier den Code etwas. Wenn Du den Zeiger verändern 
willst, in einer Funktion, dann musst Du einen Pointer auf das zu 
veränderte Ding mitgeben.

Grüsse,
René

PS: Bei mir sieht die Ausgabe dann so aus:
ptr: 601040
ptr: 60104a

[Karl H. (kbuchegg)]

> und nach jedem Funktionsaufruf soll sich das Programm merken bis
> wohin er das globale Array befüllt hat um es bei einem anderen
> Funktionsaufruf wieder weiter ab dort zu befüllen

Kann man natürlich mit Pointern lösen. Muss man aber nicht.
Warum merkst du dir nicht einfach den zuletzt benutzten Index?
Du brauchst sowieso einen Mechanmismus um zu verhindern, dass du das 
Array überläufst. Da kannst du genausogut auch dir einen Index in einer 
Variablen merken.

[Karl H. (kbuchegg)]

c_testDummy schrieb:
> hmm was genau bewirkt das ?


Soll eine Funktion eine Variable beim Aufrufer ändern können, dann sieht 
das allgemeine Schema dazu so aus

void foo( T * arg )
{
  *arg = Wert von T;
}

int main()
{
  T variable;

  foo( &variable );
}

und zwar unabhängig vom tatsächlichen Datentyp für T.

Das ist nicht anders wenn für T der Datentyp 'int' gewählt wird

void foo( int * arg )
{
  *arg = 5,
}

int main()
{
  int variable;

  foo( &variable );

  // variable hat jetzt den Wert 5
}

oder wenn, wie in deinem Fall es sich um einen Pointer-Datentyp handelt. 
Setze für T den Datentyp 'int *' ein und du erhältst

int array[5];

void foo( int * * arg )
{
  **arg = 8;
  (*arg)++;
}

int main()
{
  int * variable = &array;

  foo( &variable );

  // variable hat auf array[0] gezeigt, daher wird array[0] der Wert
  // 8 zugewiesen.
  // Gleichzeitig ist aber in der Funktion auch variable selbst
  // verändert worden, so dass es jetzt nicht mehr auf array[0], sondern
  // auf array[1] zeigt.
}

[c_testDummy (Gast)]

Ah ok, danke für die vielen Antworten.


Karl Heinz Buchegger schrieb:
> Kann man natürlich mit Pointern lösen. Muss man aber nicht.
> Warum merkst du dir nicht einfach den zuletzt benutzten Index?
> Du brauchst sowieso einen Mechanmismus um zu verhindern, dass du das
> Array überläufst. Da kannst du genausogut auch dir einen Index in einer
> Variablen merken.

Ja das mit dem Index übergebn dachte ich mir auch schon genau aus dem 
selben Grund, aber ich dachte mir das wäre zu "plump" :D

------------------------------------------------------------------------ 
--

Karl Heinz Buchegger schrieb:
> oder wenn, wie in deinem Fall es sich um einen Pointer-Datentyp handelt.
> Setze für T den Datentyp 'int *' ein und du erhältst

Rene H. schrieb:
> Versuch das mal und studier den Code etwas. Wenn Du den Zeiger verändern
> willst, in einer Funktion, dann musst Du einen Pointer auf das zu
> veränderte Ding mitgeben.

Das hat alles klarer gemacht, dank an euch !

[René (Gast)]

OT @Karl Heinz
Sag mal, bist Du Dozent oder Lehrer? Oder wurde Dir das sehr gute 
erklären können einfach in die Wiege gelegt?

Grüsse,
René

[Karl H. (kbuchegg)]

René schrieb:
> OT @Karl Heinz
> Sag mal, bist Du Dozent oder Lehrer?

Nö.

> Oder wurde Dir das sehr gute
> erklären können einfach in die Wiege gelegt?
Einfach nur oft genug gemacht, um zu wissen, wo die gedanklichen 
Probleme meistens liegen.

[DirkB (Gast)]

Du kannst auch das Ende mit einem Wert kennzeichnen, der in den normalen 
Daten nicht vorkommt.
Dann kannst du das Ende jederzeit finden.

Ein Beispiel wäre die Stringverarbeitung in C mit der '\0'