[C++] merwürdiges char array problem

[extac]

hey habe ein problem, wovon ich keine ahnung habe wieso es kommt.
hier der code erstmal

class HB{
	protected:
		char UHB[4]; //unteres halbbyte also "1111" für 15
		bool Valid;  //gültigkeit überprüfen
	public:
		char* getUHB(){
			return UHB;
		}
		bool getValid(){
			return Valid;
		}
		
		HB(int Wert){
			Valid = true;
			if(Wert>=0 && Wert<=15){
				for(int i=3; i>=0; i--){// zahl in binärzahl umrechnen
					UHB[i]= Wert%2+48;
					Wert/=2;
				}
			}else Valid = false;
		}
		HB(const HB &HB2){
			for(int i=0;i<4&&Valid;i++){
				UHB[i]=HB2.UHB[i];
			}
			Valid= HB2.Valid;
		}
};


int main() {
	HB byte(11);
	std::cout << byte.getUHB();
	return 0;
}

eigentlich klappt alles perfekt nur eine sache nervt, unzwar ist mein array nicht "1011" sondern "1011" keine ahnung wieso 5 zeichen statt 4 ausgegeben werden... das traurige ist sobald ich oben "char UHB[4]" ändere zu "char UHB[3]" oder "char UHB[5]" mache klappt das normal... aber will das nicht machen, da ich für ein unteres halbbyte halt genau 4 zeichen brauche + null terminierter 5 also UHB[4] sollte ja das optimale sein :S

[Padmak]

Genau da ist dein Problem, nach deinem Char-Array befindet sich eben kein "null terminierter"
Entweder du vergrößterst das Array, um noch ein 0-Byte anhängen zu können, oder du änderst deine getUHB-Methode auf so etwas:

std::string getUHB(){ return std::string(UHB, UHB + sizeof(UHB)); }

(Ungetestet, *dürfte* aber funktionieren)

Padmak

[Daifoku]

edit:

char uhb[5];
int zahl = 11;
uhb[0] = (char)((0x1 & zahl)) + 48;
uhb[1] = (char)((0x2 & zahl) >> 1) + 48;
uhb[2] = (char)((0x4 & zahl) >> 2) + 48;
uhb[3] = (char)((0x8 & zahl) >> 3) + 48;
uhb[4] = '\0';
std::cout << uhb;
std::cin.get();

[ƬheGame]

Offtopic Frage: Nennt man das offiziell nicht LSB/HSB und nicht UHB oder hat das tatsächlich jemand eingedeutscht ?

[extac]

Erstmal danke an euch alle, also ich will das schon als char Array behalten.
Muss ich also den '\4' immer selber auf die letzte stelle des Arrays setzten? Ich dachte wenn ich z.B char uhb[4] mache ist automatisch auf der letzten stelle der null terminierer
Das ist ne Aufgabe von einem Blatt da soll das so genannt werden, keine Ahnung wie das sonst heißt

[Shadow992]

Originally Posted by extac

Erstmal danke an euch alle, also ich will das schon als char Array behalten.
Muss ich also den '\4' immer selber auf die letzte stelle des Arrays setzten? Ich dachte wenn ich z.B char uhb[4] mache ist automatisch auf der letzten stelle der null terminierer
Das ist ne Aufgabe von einem Blatt da soll das so genannt werden, keine Ahnung wie das sonst heißt

Entweder das oder du lässt die Zeichen einzeln ausgeben, also in etwa so (oder eben in einen string umwandeln):

PHP Code:

char* uhb=byte.getUHB();
for (int i=0;i<4;i++)
       std::cout<<uhb[i]; 


[Daifoku]

der Null-Terminator wird nur gesetzt, wenn du deinen Array mit einem "String" initialisierst:

char * uhb = "1111";
uhb hat nun die Länge 5 (1111 und \0)

Wenn du einen char array mit char uhb[4]; deklarierst, musst du dich selbst um die Terminierung kümmern, da diese Deklaration nur den Speicher reserviert ohne diesen zu verändern (e.g. \0 anhängen)

Ich würde ja meinen Code verwenden :P Der erzeugt dir einen char array, ist beliebig erweiterbar und funktioniert auch mit größeren Zahlen.
Binäre Operationen sind toll und schnell

[Shadow992]

Originally Posted by Daifoku

der Null-Terminator wird nur gesetzt, wenn du deinen Array mit einem "String" initialisierst:

char * uhb = "1111";
uhb hat nun die Länge 5 (1111 und \0)

Wenn du einen char array mit char uhb[4]; deklarierst, musst du dich selbst um die Terminierung kümmern, da diese Deklaration nur den Speicher reserviert ohne diesen zu verändern (e.g. \0 anhängen)

Ich würde ja meinen Code verwenden :P Der erzeugt dir einen char array, ist beliebig erweiterbar und funktioniert auch mit größeren Zahlen.
Binäre Operationen sind toll und schnell

Wobei man bei 95% der Compiler heutzutage davon ausgehen kann, dass ein
"i/=2" in "i>>=1" automatisch optimiert wird.
Genau dasselbe ist es bei "i%=2". Aber unabhängig von der Optimierung hast du natürlich recht, binäre Operationen sind schneller.

[extac]

Originally Posted by Daifoku

der Null-Terminator wird nur gesetzt, wenn du deinen Array mit einem "String" initialisierst:

char * uhb = "1111";
uhb hat nun die Länge 5 (1111 und \0)

Wenn du einen char array mit char uhb[4]; deklarierst, musst du dich selbst um die Terminierung kümmern, da diese Deklaration nur den Speicher reserviert ohne diesen zu verändern (e.g. \0 anhängen)

Ich würde ja meinen Code verwenden :P Der erzeugt dir einen char array, ist beliebig erweiterbar und funktioniert auch mit größeren Zahlen.
Binäre Operationen sind toll und schnell

erstmal danke nochmal für die Hilfe an alle und finde dein code auch ganz ausser das du die stellen vertauscht hast .
eine frage hätte ich noch zu etwas anderem, möchte jetzt nicht ein neues thema dafür öffnen.
Unzwar versteh ich nicht genau, wann speicher reserviert werden muss und wann nicht.
z.b
wo genau ist der unterschied zwischen

int *a; und
int *a = new int;

wann muss speicher reserviert werden?
genau so auch bei arrays,

char a[5];
und
char* a = new char[5];

[Daifoku]

Zwei Dinge:
Nummer 1:

char a[5]; // Die Länge muss FEST gewählt werden. Statische Zuweisung.
char *b = new char[len]; //len kann irgendwoher kommen. Dynamische Zuweisung

Nummer 2:
Angenommen a und b werden in einer Funktion deklariert.

char a[5]; // a ist nur LOKAL verfügbar und wird nach Ende des lokalen Bereichs (return der Funktion) AUTOMATISCH gelöscht.
char *b = new char[5]; // ist GLOBAL verfügbar. Muss MANUELL mit delete []b; gelöscht werden. Ist auch nach dem return noch Verfügbar.

[extac]

habe noch eine frage, habe einen operator überladen, welcher 2 UHB miteinander oder verknüpft, z.b hb1 "1001" und hb2 "0010", habe 2 methoden, eine klappt nicht, Ich weiß aber nicht wieso,
1. (klappt)

 
HB* operator + (const HB& HB2){
			char tmp[] = "0000";
			for(int i=0; i<4 ; i++){
				if( UHB[i]=='1'|| HB2.UHB[i]=='1')
					tmp[i]='1';
			}
			return new HB(tmp);
		}

2 (klappt nicht)
.

 
HB* operator + (const HB& HB2){
			char tmp[] = "0000";
			for(int i=0; i<4 ; i++){
				if( UHB[i]=='1'|| HB2.UHB[i]=='1')
					tmp[i]='1';
			}
			HB hb(tmp);
                        return &hb;
		}

ok liegt wahrscheinlich an speicherreservierung oder so aber keine wie genau, und meine andere frage ist , bei der ersten methode muss ich den speicher in der main wieder freigeben oder? also wenn ich z.b habe
HB *hb3(hb2+hb);
wann muss speicher mit delete wieder freigegeben werden?