globales Array - Funktionen - Zeigerarithmetik

c_testDummy Gast #3313551
Lesenswert?
• ▲
▼ 
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

1
int array[500]

2


3
int funktion1 ( int *arrayptr )

4
{

5
// check bis wohin gefüllt wurde

6
// array weiter mit Werten füllen bis array[x]

7
// wenn array voll: return -1;

8
}

9


10
int funktion2 ( int *arrayptr )

11
{

12
// check bis wohin gefüllt wurde

13
// array weiter mit Werten füllen bis array[x]

14
// wenn array voll: return -1;

15
}

16


17
void main ()

18
{

19
int returnWert = 0;

20


21
while (returnWert>=0)

22
{

23
returnWert = funktion1(array);

24
returnWert = funktion2(array);

25
.

26
.

27
.

28
}

29
}


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
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Rene H. Gast #3313564
Lesenswert?
• ▲
▼ 
Hmm, wenn ich Dich richtig verstanden habe, brauchst Du dazu einen 
doppelpointer.

1
int array[500]

2


3
int funktion1 ( int **arrayptr )

4
{

5
// check bis wohin gefllt wurde

6
// array weiter mit Werten fllen bis array[x]

7
// wenn array voll: return -1;

8
}

9


10
int funktion2 ( int **arrayptr )

11
{

12
// check bis wohin gefllt wurde

13
// array weiter mit Werten fllen bis array[x]

14
// wenn array voll: return -1;

15
}

16


17
void main ()

18
{

19
int returnWert = 0;

20


21
while (returnWert>=0)

22
{

23
   int** arraypointer = &array:

24


25
returnWert = funktion1(arraypointer);

26
returnWert = funktion2(arraypointer);

27
.

28
.

29
.

30
}

31
}


Grüsse,
René
Antwort Zitieren Bearbeiten Löschen Beitrag melden
c_testDummy Gast #3313587
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Rene H. Gast #3313622
Lesenswert?
• ▲
▼ 
1
#include <stdio.h>

2
#include <stdlib.h>

3
#include <stdint.h>

4


5


6
uint8_t array[500];

7


8
void mach_was(uint8_t** ptr)

9
{

10
   uint8_t i;

11


12
   for (i = 0; i < 10; i++, (*ptr)++)

13
      (*ptr)[i] = i;

14
}

15


16


17
int

18
main (int argc, char *argv[])

19
{

20
  uint8_t* arrayptr = array;

21


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

23


24
  mach_was (&arrayptr);

25


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

27


28
  return (0);

29
}


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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #3313647
Lesenswert?
• ▲
▼ 
> 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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #3313656
Lesenswert?
• ▲
▼ 
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
1
void foo( T * arg )

2
{

3
  *arg = Wert von T;

4
}

5


6
int main()

7
{

8
  T variable;

9


10
  foo( &variable );

11
}

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

1
void foo( int * arg )

2
{

3
  *arg = 5,

4
}

5


6
int main()

7
{

8
  int variable;

9


10
  foo( &variable );

11


12
  // variable hat jetzt den Wert 5

13
}


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

1
int array[5];

2


3
void foo( int * * arg )

4
{

5
  **arg = 8;

6
  (*arg)++;

7
}

8


9
int main()

10
{

11
  int * variable = &array;

12


13
  foo( &variable );

14


15
  // variable hat auf array[0] gezeigt, daher wird array[0] der Wert

16
  // 8 zugewiesen.

17
  // Gleichzeitig ist aber in der Funktion auch variable selbst

18
  // verändert worden, so dass es jetzt nicht mehr auf array[0], sondern

19
  // auf array[1] zeigt.

20
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
c_testDummy Gast #3313836
Lesenswert?
• ▲
▼ 
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 !
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren