Puffer über Zeiger füllen

Hallo ich hab dieses Programm geschrieben um mich mit Zeiger Konvertierung etwas zu beschäftigen.

Ich will char *buff; komplett mit dem ASCII Zeichen 3 füllen.

So funktioniert es.

#include <iostream.h>
#include <fstream.h>
using namespace std;

int main (int argc, char *argv[])
{
	char 	*buff, *zgr;
	long 	*adr_zgr, adr;

	int 	i;

	buff = new char [512];

	zgr = buff;
   //	adr_zgr = (long *) zgr;  // C Style
   adr_zgr =  reinterpret_cast<long*>( zgr );   // C++ Style

	for (i = 0; i < 256 ; i+=4)
	{
		*(adr_zgr++) = 3;

	 }

	for (i = 0; i < 256 ; i+=4)
	{
		cout<<buff[i];

	 }

	delete[] buff;
	system("PAUSE");
	return 0;
}

Hier bekomme ich ein EACCESS VIOLATION

Aber ich hab 0 Ahnung warum der Fehler auftritt.
Mein Puffer kann doch 512 Byte aufnehmen

*(adr_zgr++) = 3; <-- 1 ASCII Zeichen = 1 Byte oder ?

Ich schiebe 256 mal das ASCII Zeichen 3 in den Puffer wieso krieg ich da ein EACCESS Violation ?

#include <iostream.h>
#include <fstream.h>
using namespace std;

int main (int argc, char *argv[])
{
	char 	*buff, *zgr;
	long 	*adr_zgr, adr;

	int 	i;

	buff = new char [512];

	zgr = buff;
   //	adr_zgr = (long *) zgr;  // C Style
   adr_zgr =  reinterpret_cast<long*>( zgr );   // C++ Style

	for (i = 0; i < 256 ; i++)
	{
		*(adr_zgr++) = 3;

	 }

	for (i = 0; i < 256 ; i++)
	{
		cout<<buff[i];

	 }

	delete[] buff;
	system("PAUSE");
	return 0;
}

David_pb

*(adr_zgr++) = 3; <-- 1 ASCII Zeichen = 1 Byte oder ?

Nein... adr_zgr ist ein long Pointer und bei dir ist sizeof(long) == 4. Darum wird beim inkrementieren immer 4 Byte vorangeschritten und nicht nur eins! Wenn du jetzt 256 Durchläufe in der Schleife machst landest du an der Obergrenze von 1024 Byte und dein Puffer kann nur 512 byte fassen. Du darfst also maximal 128 Durchläufe machen um die Puffergrenze nicht zu übeschreiten.

Du musst dir erst einmal im Klaren darüber sein, wie "breit" ein char ist. Normalerweise, nicht zwangsläufig, ist dies ein Byte (8 Bit). Wenn du schon ein Array von 512 chars erstellst ( [0-512[ ), dann solltest du auch in der Schleife jedes Zeichen nutzen. Wolltest du in etwa so etwas machen?

int main (int argc, char *argv[])
{
    char* buff = new char [512];
	memset(buff,3,sizeof(char)*512);
	buff[511]=0;

	char* zgr = buff;

	int i=0;
	while(*zgr)
    {
		cout<<*(zgr++);

	}
	cout << endl;
	cout << buff << endl;
	cout << endl;

	delete buff;
	return 0;
}

Ich habe buff explizit nullterminiert, damit ich buff im zweiten Aufruf noch einmal komplett ausgeben lassen kann.

David_pb

VF schrieb:

Du musst dir erst einmal im Klaren darüber sein, wie "breit" ein char ist. Normalerweise, nicht zwangsläufig, ist dies ein Byte (8 Bit).

Warum sollte das wichtig sein?

Okay, ich meinte grundsätzlich die Differenz der Größen von char und long*.

krümelkacker

Also, folgendes Programm

#include <iostream>

using namespace std;

int main()
{
    char* buff = new char[512];
    long* oha = reinterpret_cast<long*>(buff);
    unsigned const step = sizeof(long);
    for (int i = 0; i < 256 ; i+=step) {
        *(oha++) = 65;
    }
    for (int i = 0; i < 256 ; i+=step) {
        cout << buff[i];
    }
    delete[] buff;
    return 0;
}

läuft bei mir und produziert folgende Ausgabe:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Auf einem anderen Rechner kann die Ausgabe aber anders aussehen; denn das Programm ist von Implementierungsdetails abhängig (lies: "unportabel"). Folgende Implementierungsdetails können die Ausgabe beeinflussen:

sizeof(long), CHAR_BIT (bei mir: 4,
Byte-Ordnung (bei mir: Little Endian)
Zeichencodierung (bei mir: irgendwas ASCII-ähnliches)

BTW: Das Programm lehnt sich stark an das an, was Du geschrieben hast. Eine der Änderungen ersetzt 4 durch sizeof(long). Du hast zwar den Puffer groß genug gemacht, so dass mit sizeof(long)==8 auch nichts schief geht, aber wenn man dieses Implementierungsdetail schon über sizeof abfragen kann, warum dann also nicht so?

kk