Hi!
Ich komme nicht ganz klar mit dem Übergeben und der Rückgabe von
Pointern einer C Funktion.
Alles was ich machen will ist ein übergebenes Byte in einer Funktion zu
drehen und es wieder zurückzugeben.
Ich habe ein Array mit 12 Bytes, diese müssen alle gedreht werden (nicht
invertiert).
Deklariert habe ich folgendes:
Jetzt habe ich eine Routine geschrieben, welche ich das Ausgangsarray
übergeben möchte und die Funktion soll mir dann die gedrehten Daten
zurückschreiben in das andere Array.
Ich kriegs nicht hin; Verständnisspropobleme!
1
unsignedchar*ByteDrehen(unsignedchar*byte)
2
{
3
unsignedcharo,*DataGedreht_=0;
4
5
for(o=0;o<=11;o++)
6
{
7
if((byte[o]&0x01)==0x01){DataGedreht_[o]|=0x80;}
8
if((byte[o]&0x02)==0x02){DataGedreht_[o]|=0x40;}
9
if((byte[o]&0x04)==0x04){DataGedreht_[o]|=0x20;}
10
if((byte[o]&0x08)==0x08){DataGedreht_[o]|=0x10;}
11
if((byte[o]&0x10)==0x10){DataGedreht_[o]|=0x08;}
12
if((byte[o]&0x20)==0x20){DataGedreht_[o]|=0x04;}
13
if((byte[o]&0x40)==0x40){DataGedreht_[o]|=0x02;}
14
if((byte[o]&0x80)==0x80){DataGedreht_[o]|=0x01;}
15
16
return&DataGedreht_[o];
17
DataGedreht_=0;
18
}
19
}
in der MAIN dann aufgerufen:
1
*DataGedreht=ByteDrehen(&Data);
Entweder meckert der Compiler mit Implicit Ptr conversion oder er weißt
Fehler aus und compiliert nicht.
Eigentlich sollte doch bei 0x5B dann 0xDA rauskommen usw.
Kann mich mal jemadn wieder auf die Spur setzen?
CL
C. L. schrieb:> unsigned char o, *DataGedreht_ = 0;
Der Pointer "DataGedreht_" zeigt also auf NULL.
> DataGedreht_[o]
Da dereferenzierst Du einen Pointer, der auf NULL zeigt.
Ok,
das heisst dann rein nur 2 mal Übergabe und nicht als klassische
Rückgabe mit "return".
Geht denn sowas nicht als Rückgabeparameter?
Bin allerdings auch so zufrieden.
CL
C. L. schrieb:> Geht denn sowas nicht als Rückgabeparameter?
Nur, wenn Du den dafür benötigten Speicher dynamisch (mit malloc &
Co.) anforderst, oder ihn als static innerhalb der Funktion
deklarierst. Das aber kann unappetitliche Nebenwirkungen haben, wenn die
Funktion mehrfach aufgerufen wird und Du an den unterschiedlichen
Stellen annimmst, der Speicher, auf den der zurückgegebene Pointer
zeigt, wäre unverändert.
Alternativ könntest Du auch eine globale Variable dafür anlegen, aber
das ändert am Problem nichts und ist obendrein auch noch Pfusch und
Murks.
Rufus Τ. F. schrieb:> Pfusch und> Murks.
;-) neee, das wollen wir ja nicht und es ist obendrein auch ziemlich
kompliziert. Liegt aber auch an meinem Verständniss über Zeiger.
Da ist noch Luft nach oben. ;-)
Habe das dann mit den beiden Pointerübergaben im Aufruf gelöst.
Funktiniert auch!
Danke Euch.
CL
C. L. schrieb:>> Geht denn sowas nicht als Rückgabeparameter?>
Wenn Du einen Zeiger zurückgibst, ist das einfach nur eine
Speicheradresse, also eine Zahl. Du willst aber 12 Byte zurückgeben.
Es gäbe noch zwei andere Möglichkeiten:
1. Du gibst ein struct mit einem 12-Byte-Array zurück. Das ist
allerdings unflexibel, weil die Funktion dann nur exakt 12 Byte
zurückgeben kann und keine andere Längen. Je nachdem was Compiler draus
macht, kann es auch ineffizienter sein, wenn die Daten nochmal umkopiert
werden.
2. Du holst Dir mit malloc() 12 Byte dynamischen Speicher und gibst den
Zeiger darauf zurück. Dann muss der Aufrufer der Funktion allerdings
dran denken, den Speicher mit free() wieder freizugeben. Außerdem ist
malloc() recht teuer, gerade auf einem Mikrocontroller.
Daher geht man in C meistens lieber den Weg, der Funktion einen Zeiger
auf den Speicherbereich zu übergeben, in den sie ihre Daten schreiben
soll.
Hans schrieb:> Du musst beide Zeiger an die Funktion übergeben, auf die originalen> Daten und auf die gedrehten Daten.
Ich würd nochmal genau überlegen, ob die alten Daten danach überhaupt
noch gebraucht werden. Oftmals reicht nämlich ein Pointer und man
überschreibt einfach die alten Daten.
Ja, das könnte man so machen und sich ein Pointer sparen.
In diesem Fall hätte ich es aber nicht machen wollen, denn die Daten im
Ausgangsarray werden immer wieder so benötigt.
Darauf hatte ich aber nicht hingewiesen.
CL
Du könntest auch dein Problem in Teilprobleme gliedern und somit auch
"Sauberkeit" im Code halten.
Falls du es mit Zeigern lösen möchtest, dann hätte ich dir folgendes
Bsp.:
Es gibt mehrere Lösungen das Byte zu rotieren, somit musst du nicht
diese nehmen, ich finde es mit der Schleife nur "schöner" als in deinem
ersten Beitrag.
Gruß