Du bist nicht angemeldet.

Werbeanzeige

BlackViper

Frischling

  • »BlackViper« ist der Autor dieses Themas

Beiträge: 12

Wohnort: Dortmund

Beruf: InformatikStudent

  • Private Nachricht senden

11

06.08.2005, 18:14

PufferGröße

Obiger Code funktioniert prima und die Log.html gibt aus

Zitat

Die Datei wurde erfolgreich eingelesen. Groesse: 23 Byte
Der Cursor steht auf Position 0
Buffergröße: 5
Feld 0: c
Feld 1: d
Feld 2: e
Feld 3: f
Feld 4: g
Die Datei "copy.txt" wurde erfolgreich geschrieben.


Wenn Du die Größe des sBuffer mit sizeof mißt, bekommst Du aber immer den Wert 1!

C-/C++-Quelltext

1
sizeof(sBuffer)
funzt aber net für dynamischen Arrays, sondern nur für statische! Warum das so ist, vermute ich, liegt daran, daß das dynamische Array nur eine Anfangsadresse hat und die Menge von folgenden Elementen durch sizeof nicht abgezählt werden können... Vielleicht weiß da jemand besser Bescheid.

Wenn Du meinen Code nochmal genauer anschaust, siehst Du, daß ich aber ein dynamisches Array verwende und kein statisches (was Du ja vorgeschlagen hattest und mir missfällt, da ich ggf. nicht weiß, wieviel ich einlesen möchte).
Mit

C-/C++-Quelltext

1
BufferGroesse = strlen(sBuffer)
zu arbeiten, um die Elemente von sBuffer abzuzählen, hatte mich zu dem Thread hier bewogen, da es für mehr als 4 Elemente im Array funzt, aber für weniger nicht.. sehr kurios ???

Naja.. Wer sich in diesen tiefen Gefilde auskennt, möge uns bitte aufklären :D

Blacky
Fürchte nicht langsam zu gehen,
fürchte nur, stehen zu bleiben.

Anonymous

unregistriert

12

06.08.2005, 19:40

Hm also ich glaub ich hab Tomaten auf den Augen, kannst du mir mal die Zeile zeigen wo der Speicher dynamisch allokiert wird?

Und das sizeof() liefert bei statischen Arrays die Größe, da diese ja bereits zur Kompilierzeit bekannt ist, ist das ja auch kein Problem.
Um die Anzahl der Elemente in einem statischen Array herauszubekommen, kann man folgendes machen:

C-/C++-Quelltext

1
2
3
4
5
6
7
int array[ 25 ]; //hab extra int und nicht char genommen, da char ja immer 1byte is

size_t sizeOfArray = sizeof( array ); //Größe des Arrays in Bytes

size_t sizeOfInt = sizeof( int );  //Größe eines ints in Bytes

size_t numOfElements = sizeOfArray / sizeOfInt; //Anzahl der Elemente von array


//oder kurz:

size_t numElem = sizeof( array ) / sizeof( int );


Bei dynamischen Arrays liefert sizeof() die Größe des Zeigers in Bytes.
Ein array[] und ein *array können implizit ineinander umgewandelt werden.
Daher ist folgendes möglich:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
int* pInt( 0 ); //Ein Zeiger auf int, mit 0 (=NULL) initialisiert

int array[];   //Ein int array mit unbekannter Größe


array = new int[ 3 ]; //array wird hier implizit als Zeiger betrachtet und verweist

                              //von nun an auf einen Speicherblock der Platz für

                              //3ints hat.


pInt = array;          //pInt verweist nun auf den selben Speicherblock


*array = 1;            //array wird wieder als Zeiger betrachtet und in die

                            //Zieladresse wird der Wert 1 kopiert

array[ 1 ] = 1;       //array wird als ein array betrachtet und an die zweite

                            //Stelle wird die 1 kopiert

*( array + 2 * sizeof( int ) ) = 3; //Hier wird das array wieder als Zeiger

                                                //betrachtet, der Zeiger wird um 2 mal

                                                //die Größe eines ints erhöht und zeigt

                                               //somit auf das dritte Element des arrays

                                               //nun wird in dieses die 3 kopiert


*( pInt + sizeof( int ) ) = 2;      //Hier geschieht das gleiche wie darüber

                                             //mit array, nur ist pInt bereits ein Zeiger

pInt[ 2 ] = 12;                        //Der Zeiger wird als array betrachtet  und

                                             //in das dritte Element wird die 12 kopiert


delete array;                          //Wieder wird das array als zeiger betrachtet


Ich hoffe das ist einigermaßen Hilfreich

BlackViper

Frischling

  • »BlackViper« ist der Autor dieses Themas

Beiträge: 12

Wohnort: Dortmund

Beruf: InformatikStudent

  • Private Nachricht senden

13

10.08.2005, 15:29

Dyn. Array

Tja, ich denke mal, an dieser Stelle wird das dynamische Array alloziiert:

C-/C++-Quelltext

1
2
if( pFile->Read( set, pBuffer ) == TB_OK ) //read set-many Bytes

                BufferGroesse = set;


Die Read-Funktion liest so viele Zeichen, wie set angibt, ein und speichert sie ab der Adresse, die pBuffer angibt.
Also wenn Du 5 Zeichen liest, dann wird ab sBuffer[0] stets das zu lesende Zeichen zugewiesen.. also sBuffer[0], sBuffer[1] usw.

BlackViper
Fürchte nicht langsam zu gehen,
fürchte nur, stehen zu bleiben.

Werbeanzeige