Array als pointer in Funktion übergeben, dort beschreiben und wieder zurück

Lothar M. schrieb:
>> generate_array(&Array);
>> generate_clock(uint8_t *array[])

_array ist richtig. die funktion heißt auch so.

Rolf M. schrieb:
> Es wäre sehr hilfreich, zu wissen, wie Array definiert ist.

uint8_t Array[110];

Lothar M. schrieb:
> Lass da mal das & weg.

Mhh, dann kommen erst kryptische Zeichen und dann irgendwann gar nichts 
mehr

Wie wärs wenn du mal den kompletten Code anbietest? Was ist signs, wo 
ist generate_array .....

generate_array(uint8_t *array);

Ich "rate" mal, dass dem TO das hier vielleicht hilft:

1

#include <stddef.h>

2

#include <stdint.h>

3

#include <stdio.h>

4

5

#define NUMBER_OF_ELEMENTS 110

6

7

#define ARRAY_SIZE(a) (sizeof (a) / sizeof (a[0]))

8

9

uint8_t array [NUMBER_OF_ELEMENTS] = {0};

10

11

void generate_stuff (uint8_t* array_ptr, size_t array_size)

12

{

13

  for (size_t i = 0; i < array_size; ++i)

14

  {

15

    uint8_t fancy_value_to_assign = i; 

16

17

    *(array_ptr + i) = fancy_value_to_assign;

18

19

    // or

20

    // array_ptr[i] = fancy_value_to_assign;

21

  }

22

}

23

24

int main ()

25

{

26

  generate_stuff (array, ARRAY_SIZE (array));

27

28

  for (size_t i = 0; i < ARRAY_SIZE (array); ++i)

29

  {

30

    printf ("array[%lu] =  %u\n", i, array[i]);

31

  }

32

33

  return 0;

34

}

Schönen Sonntag!

Wenn du im Quelltext den Namen eines Arrays verwendest, dann wird 
bereits ein Pointer übergeben. Deswegen kann die Funktion den Inhalt des 
Arrays auch verändern.

1

char[] text1="Hallo"; // 6 Bytes, wegen der abschließenden 0.

2

3

char* zeiger1=text1; // Das ist valide

4

5

char* text2="Welt!" // wieder 6 Bytes

6

7

char[] array2=text2; // Auch das ist valide

8

9

function text_ausgeben(char* text)

10

{

11

    while (*text != 0)

12

    {

13

       char c=*text;

14

       ausgeben(c);

15

       text++;

16

    }

17

}

18

19

// Oder so:

20

21

function text_ausgeben(char* text)

22

{

23

    for (i=0; i<strlen(text); i++)

24

    {

25

        char c=text[i];

26

        ausgeben(c);

27

    }

28

}

29

30

// Oder so:

31

32

function text_ausgeben(char[] text)

33

{

34

    int i=0;

35

    while (*(text+i) != 0)

36

    {

37

       char c=*(text+i);

38

       ausgeben(c);

39

       i++;

40

    }

41

}

42

43

function text_ausgeben(char* text)

44

{

45

    for (i=0; text[i]!=0; i++)

46

    {

47

        char c=text[i];

48

        ausgeben(c);

49

    }

50

}

Alle diese Funktionen kannst du wahlweise mit text1, zeiger1, text2, 
array2 und einem String-Literal (z.B. "blabla") aufrufen.

In allen Fällen ist der Übergabeparameter "text" ein Zeiger auf Zeichen. 
Die Deklaration "char[]" deutet an, dass es viele Zeichen sind, im 
Gegensatz dazu sagt "char*" nicht aus, ob es nun ein oder viele Zeichen 
sind. Beide Schreibweisen sind gegeneinander austauschbar. Wie du an den 
obigen Quelltexten siehst, kann man die Zugriffe auch wild mischen.

Man kann als Funktionsparameter einen char* benutzen, und dann mit Array 
index zugreifen. Umgekehrt herum kann der Funktionsparameter auch ein 
char[] sein, aber man inkrementiert ihn als sei es ein Pointer.

Technisch gesehen ist beides identisch. Du kannst das am 
Assembler-Listing sehen.

Stefanus F. schrieb:

> function text_ausgeben(char* text)

Ob der Compiler das mag? Ansonsten hast Du natürlich Recht :-)

Dirk schrieb:
> Stefanus F. schrieb:
>
>> function text_ausgeben(char* text)
>
> Ob der Compiler das mag? Ansonsten hast Du natürlich Recht :-)

Ok, das void für den Rückgabewert fehlt.

Rolf M. schrieb:
> Stefanus F. schrieb:
>> Ok, das void für den Rückgabewert fehlt.
>
> Ja, und das "function" existiert nicht.

Ich fange an, die Programmiersprachen durcheinander zu werfen. Kommt 
davon, wenn man immer mit IDE arbeitet, die einem das Denken teilweise 
abnimmt.

Stefanus F. schrieb:
> Ok, das void für den Rückgabewert fehlt.

Nur für Leute, die sich gern selbst beim Schreiben zusehen, fehlendes 
void erzeugt höchstens eine Warnung.
mfg
Achim

Apollo M. schrieb:
> void text_ausgeben(const char text[const]) {
>    uint8_t i=0;
>    while (char c=*(text+i++), c) putc(c);
> }

Ist sicher richtig, ich wollte den TO allerdings nicht durch derart 
komplexe Ausdrücke verwirren.

Apollo M. schrieb:

> void text_ausgeben(const char text[]) {
>    char c;
>    while (c=*(text++), c) putc(c);
> }

Damit das funktioniert, muss text ein "valider C-String" sein, also mit 
einer NULL als letztem Element. Der TO hat einen Fall mit bekannter 
Länge.

Apropos TO... liest Du noch mit?

Es geht doch nur darum, die Varianten zu beleuchten, wie man Arrays an 
Funktionen übergibt. Ihr beschäftigt euch lieber mit Nebensachen, die 
vom Thema ablenken.