Null im Array bricht Array ab

[Joachim .. (joachim_01)]

Array: Wie 0 senden?

Hi,
ich möchte einer Funktion folgendes übergeben:
unsigned char commandToDisplay2[5] = {0x1B,'G','B',0};  //cursor off ESC 
G B 0
Das letzte Datenbyte, in dem Fall die 0, schaltet den Cursor aus, erst 
dann kommt die Ende-Kennung 0.

Wenn ich dies dann an folgende Funktion übergebe:

void  SendCommand(unsigned char buf[])
{ 
  unsigned char i, j, bcc, test;
  j = strlen (buf);  
  test = i2c_write(0x11); //  Send  DC1
  bcc =  0x11;
  test += i2c_write(j); //  Send  data  length
  bcc = bcc + j;  
  for(i=0;  i  <  j;  i++) {
        test += i2c_write(buf[i]);
        bcc = bcc + buf[i];
  };
  i2c_write(bcc); //  Send  checksum
}

dann berechnet strlen(buf) einen falschen Wert, der String ist um ein 
Byte zu kurz.


strlen(buf[]) hab ich probiert, gleiches Ergebnis. Wie macht man das am 
Elegantesten?

[max (Gast)]

nim statt strlen() sizeof()

strlen ist, wie der Name eigentlich auch ausdrückt für Zeichenketten 
(Strings) gedacht und nicht für Arrays. In C werden Zeichenketten am 
Ende immer mit dem Char 0x00 abgeschlossen. Dieser wird bei strlen nicht 
mitgezählt, da er ja kein darstellbares Zeichen ist.

[Jens B. (nixiefreak)]

Du könntest auch bei der Startadresse des Arrays anfangen und dann bei 
einem Steuerzeichen deiner Wahl die for-Schleife verlassen.

[Joachim .. (joachim_01)]

>nim statt strlen() sizeof()
Das funktioniert noch schlechter, sizeof() berechnet soviel ich weiß nur 
die größe des Datentypen, hier also für char.

>strlen ist, wie der Name eigentlich auch ausdrückt für Zeichenketten
>(Strings) gedacht und nicht für Arrays.
Aber das könnt mich weiterbringen, ich muß aus dem Array nen String 
machen, dann könnt's gehen.

[Martin (Gast)]

j = sizeof(buf) / sizeof(buf[0]);

Länge des gesamten Arrays / Länge des ersten Elements = Anzahl der 
Elemente.
Die muß funktionieren, wird genauso im C-Standard vom Compiler 
gefordert.

[Joachim D. (Firma: JDCC) (scheppertreiber)]

void  SendCommand(unsigned char buf[], int len)
{ 
  unsigned char i, bcc, test;
  
  test = i2c_write(0x11); //  Send  DC1
  bcc =  0x11;
  test += i2c_write(j); //  Send  data  length
  bcc = bcc + j;  
  for(i=0;  i  <  len;  i++) {
        test += i2c_write(buf[i]);
        bcc = bcc + buf[i];
  };
  i2c_write(bcc); //  Send  checksum
}

Einfach die Länge als Argument mitgeben ...

[Martin (Gast)]

Oh seh grad, daß das Array als Paramter übergeben wird.
Da funktioniert meine Lösung so nicht.

So sollte es gehen:

void  SendCommand(unsigned char buf[], int len) {...}

...
len = sizeof(buf) / sizeof(buf[0]);
SendCommand(buf[], len);
...

[Joachim .. (joachim_01)]

Danke für die Hilfe.

Ich werde es wohl mit der zusätzlichen Längenübergabe machen.

[Holger W. (holgerw)]

ich geb die Länge auch gern im ersten Element des Arrays mit.

[Joachim .. (joachim_01)]

len = sizeof(buf) / sizeof(buf[0]);
Hmm. Wiki schreibt:
In the programming languages C and C++, the unary operator sizeof is 
used to calculate the sizes of datatypes, in number of bytes.

...und buf ist ja vom Typ Datentyp char, also sollte 1 rauskommen... was 
nicht das gewünschte ist...

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Joachim ... schrieb:
> len = sizeof(buf) / sizeof(buf[0]);
> Hmm. Wiki schreibt:
> In the programming languages C and C++, the unary operator sizeof is
> used to calculate the sizes of datatypes, in number of bytes.
>
> ...und buf ist ja vom Typ Datentyp char, also sollte 1 rauskommen... was
> nicht das gewünschte ist...

Naja, schau's Dir nochmal genau an :-)

[Wurstbrot (Gast)]

sizeof( ... ) wird zur Kompilierzeit bestimmt. Wenn also ein Array mit 
unbekannter Größe übergeben wird, kann man dort sizeof nicht einsetzen. 
Die richtige Lösung ist in diesem Fall wirklich, einen zweiten Parameter 
zu übergeben, der die Länge des Buffers angibt.

[Rolf Magnus (Gast)]

Wurstbrot schrieb:
> sizeof( ... ) wird zur Kompilierzeit bestimmt. Wenn also ein Array mit
> unbekannter Größe übergeben wird, kann man dort sizeof nicht einsetzen.

Das ist nur die halbe Wahrheit. sizeof() kann man prinzipiell immer 
einsetzen, aber wenn man die Details nicht kennt, kommt nicht unbedingt 
das raus, was man vielleicht erwartet.
Eins dieser Details ist, daß man in C ein Array nicht direkt an eine 
Funktion übergeben kann. Es sieht zwar bei der obigen Definition so aus, 
als würde das geschehen, aber das täuscht. Die C-Erfinder fanden das 
damals intuitiver, aber es ist meiner Meinung nach genau das Gegenteil.

void  SendCommand(unsigned char buf[])

Hier sieht es zwar so aus, als sei buf ein Array, aber in diesem Falle 
tritt eine C-Spezialregel inkraft, nach der bei einem Funktionsparameter 
die eckigen Klammern nicht wie sonst bei Definitionen üblich für ein 
Array stehen, sondern stattdessen für einen Zeiger. Das heißt, es ist zu 
100% äquivalent zu

void  SendCommand(unsigned char* buf)

Deshalb kommt für sizeof(buf) die Größe eines Zeigers heraus. Man darf 
übrigens zwischen die  eckigen Klammern auch eine Zahl als Arraygröße 
schreiben, aber die hat keinerlei Bedeutung und wird schlichtweg 
ignoriert.