merwürdiges char array problem

09/01/2015 23:44 extac#1
hey habe ein problem, wovon ich keine ahnung habe wieso es kommt.
hier der code erstmal
Code:
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
09/02/2015 00:18 Padmak#2
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:
Code:
std::string getUHB(){ return std::string(UHB, UHB + sizeof(UHB)); }
(Ungetestet, *dürfte* aber funktionieren)

Padmak
09/02/2015 00:43 Daifoku#3
edit:

Code:
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();
09/02/2015 10:08 ƬheGame#4
Offtopic Frage: Nennt man das offiziell nicht LSB/HSB und nicht UHB oder hat das tatsächlich jemand eingedeutscht ?
09/02/2015 10:57 extac#5
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 :D
09/02/2015 13:49 Shadow992#6
Quote:
Originally Posted by extac View Post
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 :D
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]; 
09/02/2015 14:28 Daifoku#7
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 :)
09/02/2015 17:11 Shadow992#8
Quote:
Originally Posted by Daifoku View Post
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. :)
09/02/2015 21:51 extac#9
Quote:
Originally Posted by Daifoku View Post
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 :D und finde dein code auch ganz :D ausser das du die stellen vertauscht hast :p.
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
Code:
int *a; und
int *a = new int;
wann muss speicher reserviert werden?
genau so auch bei arrays,
Code:
char a[5];
und
char* a = new char[5];
09/02/2015 22:50 Daifoku#10
Zwei Dinge:
Nummer 1:

Code:
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.

Code:
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.
09/03/2015 18:02 extac#11
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)
Code:
 
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)
.
Code:
 
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?