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

[Frank (Gast)]

Guten morgen,
ich möchte einen Array einer Funktion übergeben. In dieser Funktion soll 
in diesem Array dann werte gesetzt werden, welch ich dann in der 
main-funktion wieder verwende. Die Elemente des arrays (dort sollen dann 
nur nullen und einsen drinn stehen) sehe ich mir dann über UART an. Doch 
leider bekomme ich nur kryptische Zeichen heraus

generate_array(&Array);
for (n=0; n<110; n++)
{
  if(Array[n]==1) uart_transmit(signs[n][0]);
  else uart_transmit(' ');
}
uart_sendString("\n\r");

in einer anderen c-file ist dann die Funktion

void generate_clock(uint8_t *array[])
{
  uint8_t n;
  for (n=0; n<110; n++)
  {
    if(signs[n][1]==1) *array[n] = 1;
    else *array[n] = 0;
  }
}

Später möchte ich in der hauptfunktion dann nicht mehr auf signs 
zugreifen, sondern einen LED-Streifen ansteuern. Momentan lasse ich mir 
das ergebnis aber über uart am pc ausgeben, damit ich die Fehler 
einfacher sehen kann. Der UART an sich funktioniert. Dort gibt es keine 
Probleme

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Frank schrieb:
> generate_array(&Array);
> generate_clock(uint8_t *array[])
_clock oder _array?

> generate_array(&Array);
Lass da mal das & weg. Array selbst ist schon ein Zeiger auf ein Array. 
Wie ist Array definiert?

[Rolf M. (rmagnus)]

Frank schrieb:
> generate_array(&Array);

Es wäre sehr hilfreich, zu wissen, wie Array definiert ist.

Frank schrieb:
> void generate_clock(uint8_t *array[])

Das ist ein Zeiger auf einen Zeiger auf uint8_t. Du kannst daran ein 
Array aus Zeigern übergeben. Wolltest du das?

[Frank (Gast)]

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

[derjaeger (Gast)]

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

[devzero (Gast)]

generate_array(uint8_t *array);

[Dirk (Gast)]

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

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

#define NUMBER_OF_ELEMENTS 110

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

uint8_t array [NUMBER_OF_ELEMENTS] = {0};

void generate_stuff (uint8_t* array_ptr, size_t array_size)
{
  for (size_t i = 0; i < array_size; ++i)
  {
    uint8_t fancy_value_to_assign = i; 
    
    *(array_ptr + i) = fancy_value_to_assign;
    
    // or
    // array_ptr[i] = fancy_value_to_assign;
  }
}

int main ()
{
  generate_stuff (array, ARRAY_SIZE (array));
  
  for (size_t i = 0; i < ARRAY_SIZE (array); ++i)
  {
    printf ("array[%lu] =  %u\n", i, array[i]);
  }
  
  return 0;
}

Schönen Sonntag!

[Stefan F. (Gast)]

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.

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

char* zeiger1=text1; // Das ist valide

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

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

function text_ausgeben(char* text)
{
    while (*text != 0)
    {
       char c=*text;
       ausgeben(c);
       text++;
    }
}

// Oder so:

function text_ausgeben(char* text)
{
    for (i=0; i<strlen(text); i++)
    {
        char c=text[i];
        ausgeben(c);
    }
}

// Oder so:

function text_ausgeben(char[] text)
{
    int i=0;
    while (*(text+i) != 0)
    {
       char c=*(text+i);
       ausgeben(c);
       i++;
    }
}

function text_ausgeben(char* text)
{
    for (i=0; text[i]!=0; i++)
    {
        char c=text[i];
        ausgeben(c);
    }
}

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.

[Dirk (Gast)]

Stefanus F. schrieb:

> function text_ausgeben(char* text)

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

[Stefan F. (Gast)]

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. (rmagnus)]

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

Ja, und das "function" existiert nicht.

[Stefan F. (Gast)]

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.

[J. Zimmermann (Gast)]

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. (Firma: @home) (majortom)]

Stefanus F. schrieb:
> function text_ausgeben(char[] text)
> {
>     int i=0;
>     while (*(text+i) != 0)
>     {
>        char c=*(text+i);
>        ausgeben(c);
>        i++;
>     }
> }

oder so

//c99!
void text_ausgeben(const char text[const]) {
   uint8_t i=0;
   while (char c=*(text+i++), c) putc(c);
}


mt

[Stefan F. (Gast)]

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. (Firma: @home) (majortom)]

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

oder gleich als einzeiler!

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

[Rolf M. (rmagnus)]

J. Zimmermann schrieb:
> 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.

Wenn du nichts hinschreibst, ist es aber nicht implizit void, sondern 
int. Man muss also einen Wert zurückgeben, sonst ist das Verhalten 
undefiniert. Und ein "return 0;" ist länger als ein "void ". Lohnt sich 
also auch für Schreibfaule eigentlich nicht. Abgesehen davon, dass man 
Code warnungsfrei schreibt.

[Apollo M. (Firma: @home) (majortom)]

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

now without bugs!

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

[Dirk (Gast)]

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?

[Stefan F. (Gast)]

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.