3. char * als Funktionsparameter

char * als Funktionsparameter

  • K

    Aloha zusammen,

    da ich nicht in einem Stichwort mein Problem schildern kann, bin ich leider bei der Forumssuche nicht weiter gekommen : /.

    Ich vermute, dass ich einfach mit der Pointergeschichte noch nicht ganz durchgestiegen bin: umso wichtiger nun da reinen Tisch zu machen : ).

    Folgendes Szenario:

    packetc.h:

    class packetc
{
private:
 char * buffer;    // Inhalt des Packets
public:
 // Konstruktor / Destruktor:
 packetc()  { buffer = new char[1024]; };
 ~packetc() { delete [] buffer; };

 // Funktionen zum Packet fuellen:
 void fill(char * c) { *buffer = *c; };     // Hier ist mein Problem!

 // Funktionen zum Inhalt ausgeben:
 char * content() { return buffer; };
};

    main.cpp:

    #include "packetc.h"
#include <iostream>

int main()
{
 packetc packet;
 char * buffer = new char[1024];

 std::cout << "Inhalt des Packets: ";
 std::cin >> buffer;                      // Ueberlauf kann sein, ist hier vereinfacht.
 std::cout << "Gebe den Inhalt aus: " << packet.content(); // Fehlende \0, vereinfacht.

 delete [] buffer;
 return 0;
}

    Das Problem ist, dass nur das erste Zeichen ausgegeben wird. Ich vermute den Fehler in der Übergabe. Ich dachte mit

    *buffer = *c

    erreiche ich: In das Feld, auf das buffer zeigt, schreibe den Inhalt des Feldes, auf das c zeigt? Ist das so korrekt?

    (Beispiel:)

    Inhalt des Packets: hallo
Gebe den Inhalt aus: h ===================================(...)

    Ich hoffe Ihr versteht mein Problem ; ).

    MfG,

    kausa.

    0
  • Administrator 

    char* pChar = new char[1024];

    Hier passiert nichts anderes, als das 1024 * sizeof(char) Bytes in einem aneinander hängendem Block für dich reserviert wird. Zurückgegeben wird die Adresse auf das erste Byte dieses Blockes.

    Wenn du nun das folgende machst:

    // Angenommen pSrc und pDest sind beides solche Blöcke:
*pDest = *pSrc;

    Dann dereferenzierst du diesen Zeiger auf die Adresse des ersten Bytes. Es wird geschaut was für ein Typ die Zeiger haben und entsprechend wird auf das erste Element des Blocks zugegriffen. Dann findet die Zuweisung statt. Du kopierst also genau ein Element und den Rest rührst du nicht an.

    Um alles zu kopieren, musst du also über alle Elemente iterieren, was ja ganz einfach mit Zeigern geht:

    for(int i = 0; i < Size; ++i)
{ *pDest++ = *pSrc++; }

    Oder man verwendet gleich die Algorithmen aus der Standard Bibliothek:

    #include <algorithm>

std::copy(pSrc, pSrc + Size, pDest);

    Die Bereichsprüfung solltest du natürlich nicht vergessen. Die Destination sollte immer gleichviel oder mehr Speicherplatz besetzen, als die Source.

    Ich hoffe das hilft weiter.

    Grüssli

    0
  • ?

    Der Zeiger zeigt nur auf das erste Zeichen, aber mit Zeigerarithmetik kannst du über das gesamte Feld iterieren.

    0
  • K

    Ah! Vielen lieben Dank. : ).

    Dann war meine Vermutung richtig. Ich bin beruhigt, wieder etwas gelernt : ).

    0
  • K

    Verzeiht den Doppelpost.

    Bezüglich:

    Dravere schrieb:

    Die Bereichsprüfung solltest du natürlich nicht vergessen. Die Destination sollte immer gleichviel oder mehr Speicherplatz besetzen, als die Source.

    Wie kriege ich denn den benötigten Speicherplatz heraus, ohne den Pointer zu iterieren, wenn ich nicht weiß, wie groß das Array ist?

    char buffer = new char[iDynamisch];
int iSize = sizeof(*buffer); // liefert die Groeße des ersten Feldes: 1
    0
  • D

    Normalerweise merkt man sich die Grösse.

    0
Anmelden zum Antworten