char[] mit Hex-Werten bei Parameterübergabe initialisieren?

[Alexander I. (daedalus)]

Hallo,
bevor ich meine Frage stelle, erstmal etwas C-Code:

unsigned char drawText(char message[], int x, int y)
{
  // Message-Verarbeitung
}

Funktionsaufruf 1:

char mychar[] = "hallo welt!"
drawText(mychar, 10,15); // -> Funktioniert

Funktionsaufruf 2:

drawText("hallo welt!", 10,15); // -> Funktioniert auch

Funktionsaufruf 3:

char mychar[] = {0x01, 0x02, 0x03}
drawText(mychar, 10,15); // -> Funktioniert ebenfalls

Funktionsaufruf 4:

drawText({0x01, 0x02, 0x03}, 10,15); // -> Funktioniert NICHT!

Jetzt lautet meine Frage:
Wie kann ich einer Funktion einen char[] übergeben OHNE das ich vorher 
eine Variable deklarieren muß (siehe 3.)?

Ich möchte also drawText so aufrufen wie in 2. aber eben mit von mir 
definierten (nicht "druckbaren") Hex-Zeichen. Ich bin mir fast sicher, 
dass C da ein Makro anbietet, aber weder im Google noch hier hab ich was 
gefunden ... achso, stdio und Konsorten fallen aus Speicherplatzgründen 
schonmal aus dem Rahmen :) Bei 4. sagt der IAR EW430 übrigends:
Error[Pe029]: expected an expression.


Ich hoff ihr könnt mir helfen.

[Johannes M. (johnny-m)]

Einen Textstring übergibt man nicht als Array, sondern als Zeiger. 
Überhaupt ist es fast immer sinnvoll (und machbar), keine Arrays an 
Funktionen zu übergeben, sondern das mit einem Zeiger auf das erste 
Array-Element zu erledigen.

[Matthias (Gast)]

Ich vermute, das wird nicht gehen, weil der Compiler solche Übergaben 
wohl als call_by_reference macht, also er übergibt nicht deine Werte, 
die in der variablen stehen, sondern nur den Pointer, wo im RAM diese 
Werte stehen.
Und wenn du jetzt diskret Werte übergeben willst, müssen diese dann im 
RAM stehen, also in einer Variablen....

Bin mir nicht ganz sicher, aber hatte schon selbiges Problem

[Johannes M. (johnny-m)]

BTW: Schau Dir mal an, wie z.B. die Standard-Funktionen zur 
Stringausgabe definiert sind (printf und Verwandte). Da wird auch 
jeweils nur ein Zeiger übergeben. Am besten mal im Kernighan & Ritchie 
nachschauen, da stehen afair auch Beispiele drin.

[Alexander I. (daedalus)]

Ich hatte grade mal die Idee beim Kollegen printf() zu spicken. Es 
funktioniert:

drawText("\x01\x02\x03", 10,15); // -> Funktioniert!

Der Compiler erzeugt die Zeichenkette im ROM und übergibt der Funktion 
einen Pointer dorthin.

Gefunden hab ich das mit dem \x hier:
http://www.cplusplus.com/reference/clibrary/cstdio/printf.html

[Karl H. (kbuchegg)]

Alex Wurst wrote:

> Funktionsaufruf 4:
>

> drawText({0x01, 0x02, 0x03}, 10,15); // -> Funktioniert NICHT!
>

>
> Jetzt lautet meine Frage:
> Wie kann ich einer Funktion einen char[] übergeben OHNE das ich vorher
> eine Variable deklarieren muß (siehe 3.)?

So, gar nicht.
Man könnte höchstens machen

  drawText( "\x01\x02\x03", 10, 15 );

aber auch das ist nicht 100% identisch, weil der zwischendurch
generierte String die Länge 4 hat (wegen der abschliessenden 0)

>
> Ich möchte also drawText so aufrufen wie in 2. aber eben mit von mir
> definierten (nicht "druckbaren") Hex-Zeichen.

Dann lerne wie man Hex-Zeichen in einen String einbetten kann
(Tip: Genauso wie ich es da oben gemacht habe)

[Alexander I. (daedalus)]

@Johannes:
2 Dumme ein Gedanke in Bezug auf printf() ;)

Hat sich dann somit wohl geklärt. Danke.

[marc (Gast)]

Also ich würd sagen dem fehl die /0 am ende eines Strings, wenn man 
einen string per "" einträgt wird ja am ende die NULL also /0 angehängt. 
Daher funktionierend ie ersten beiden Aufrufe. Der dritte dürfte 
eigentlich cniht funktionieren, hat bei mir nciht 100%ig gestimmt wes 
wurden mehr als 3 Zeichen Zeichen ausgegeben. und der 4. Aufruf tut bei 
mir so auch nicht. Versuchs mal mit:

char mychar[] = {0x01, 0x02, 0x03, 0x00};
drawText(mychar, 10,15);

drawText({0x01, 0x02, 0x03, 0x00}, 10,15);

Gruß Marc

[Alexander I. (daedalus)]

@Marc
Du hast Recht, da hab ich das Beispiel wohl etwas zu sehr vereinfacht. 
Es muß hinten auf jeden Fall noch ein 0x00 dran bei Beispiel 3! 
Ansonsten wird der Text solange rausgeblubbert bis irgendwann mal 
zufällig ein 0x00 kommt.

Ist echt immer faszinierend wie lebendig dieses Forum ist :) Danke an 
alle.

[Klaus F. (kfalser)]

Ich denke, folgendes ist was Du suchst.
Der Parameter ist eine Zeichenkette (char[]) mit Spezial-Zeichen, welche 
in Hex angegeben werden. Trotzdem wird auch in diesem Fall nur ein 
Zeiger auf den temporären String an die Funktion übergeben.

drawText("\x01\x02\x03", 10,15);


Übrigens ist Dein Beispiel 3 falsch.
Die Funktion drawText() weiss nichts über die Länge von message[] und 
wird sich deshalb an die C-Convention halten daß der String mit einem 
NULL-Character '\0* endet. Bei Beispiel 1 und 2 schließt der Compiler 
die Zeichenkette automatisch mit '\0' ab.
In Deinem Beispiel 3 definierst Du aber ein Feld von char ohne 
Längenangabe mit expliziter Initialisierung.
Der Unterschied dazu ist daß der Compiler in diesem Fall das Feld nicht 
mit '\0' abschließt, sondern das Feld mit genau 3 chars definiert.
Wenn Du dieses Feld an drawText() übergibts, dann fehlt der Anschluß für 
den String und drawText schreibt die zufällig in Speicher folgenden 
Zeichen bis irgendwann eine Null gelesen wird.

Klaus

[Klaus F. (kfalser)]

Da war ich wohl ein wenig zu langsam !