Großes Problem mit Aufgabe (Umwandlung String -> TBCD String) *heul*

Hallo!
Ich habe ein kleines Problem mit dieser Aufgabe (naja eigentlich ist es ein riiiiiiiiiiiiiiesiges Problem!!!). Leider ist die Aufgabe ernorm wichtig und deshalb muss ich sie unbedingt lösen. Vielleicht kann mir jemand helfen? Ich weiß leider nicht wie ich die Aufgabe angehen soll!

Aufgabenstellung:

Implementieren Sie Funktionen, die eine Telefonnummer in einen TBCD String umwandelt und umgekehrt.
Gehen Sie davon aus, dass es keine Telefonnummern mit mehr als 32 digits gibt. Benutzen Sie die folgenden Definitionen:

const int BCD_LEN = 16;

struct BCD {

int len;
char digits[BCD_LEN];

};

Erklärung:

Ein OCTET STRING ist ein character Array. Diese werden benutzt, um Telefonnummern in der Darstellung BCD zu kodieren. Der folgende Ausschnitt aus einer GSM Spezifikation definiert einen TBCD-String als einen OCTET String und erläutert die Kodierung.

TBCD-STRING::=OCTET STRING

Dieser Datentyp (TBCD) wird gebraucht, um mehrere Zeichen von 0 bis 9, , #, a, b, c darzustellen, zwei Zeichen pro Oktett (ein Oktett = 8 Bit). Dabei ist jedes Zeichen kodiert: 0000 bis 1001 (0 bis 9), 1010 (), 1011 (#), 1100 (a), 1101 (b), 1111 (c). 1111 wird als Füllzeichen benutzt, wenn die Anzahl der Zeichen ungerade ist. Die Bits 8765 des Oktetts n werden für das Verschlüsseln des Zeichens 2n und die Bits 4321 des Oktetts n für das Verschlüsseln des Zeichens 2(n-1)+1 benutzt.

Hallo,

es wäre schön, wenn Du mal schreiben würdest, was Du Dir dazu bisher überlegt hast.

Die von Dir dargestellte Aufgabe ist bei weitem kein riesiges Problem! Aber Du kannst nicht erwarten, dass sich hier Leute im Forum hinsetzen und Deine Arbeit machen. -- Wo leben wir denn?

Ich denke es ist jeder gerne bereit Dir zu helfen-- solange Du auch selbst was dazu tust! Also... gib mal ein paar mehr Informationen über Deine bisherigen Ergebnisse raus.

Also bis jetzt hab ich mir folgendes überlegt:

#include <iostream>
using namespace std;

const int BCD_LEN = 16;

struct BCD {
    int len;
    char digits[BCD_LEN];
};

int get_code(char x) {
    switch (x) {

	case ('0'): {
	    return 0;
	}
	break;
	case ('1'): {
	    return 1;
	}
	break;
	case ('2'): {
	    return 2;
	}
	break;
	case ('3'): {
	    return 3;
	}
	break;
	case ('4'): {
	    return 4;
	}
	break;
	case ('5'): {
	    return 5;
	}
	break;
	case ('6'): {
	    return 6;
	}
	break;
	case ('7'): {
	    return 7;
	}
	break;
	case ('8'): {
	    return 8;
	}
	break;
	case ('9'): {
	    return 9;
	}
	break;
	case ('*'): {
	    return ((1<<1)+(1<<3));
	}
	break;
	case ('#'): {
	    return (1+(1<<1)+(1<<3));
	}
	break;
	case ('a'): {
	    return ((1<<2)+(1<<3));
	}
	break;
	case ('b'): {
	    return (1+(1<<2)+(1<<3));
	}
	break;
	case ('c'): {
	    return (1+(1<<1)+(1<<2)+(1<<3));
	}
	break;
	default: {
	    return -5;
	}
	break;
    }
}

//von Telefonnnummer nach BCD
void encode (char* from,int size, BCD& to) {

    int pos_ger = 0;	//gerade Zeichen
    int pos_unger = 1;	//ungerade Zeichen
    int bcd_pos = 0;	//Position im BCD_String

    int teil1; int teil2;

    while (pos_ger<(size-1)) {   
	char tmp = from[pos_ger];

	teil1 = get_code(tmp);	//Bitcode holen
	teil1 = teil1 << 4;	//Teil1 nach links verschieben  X X X X 0 0 0 0

	pos_ger= pos_ger+2;

	if (pos_unger<(size-1)) {

	    char tmp = from[pos_unger];

	    teil2 = get_code(tmp);	//Bitcode holen

	    pos_unger = pos_unger+2;   

	} else {

	    teil2 = 1 + (1 << 1) + (1 << 2) + (1 << 3);	//Füllzeichen falls Anzahl Zeichen ungerade

	}

	//hier noch Teil1 + Teil2 zusammenfügen X X X X Y Y Y Y

	char zusammen = teil1 + teil2;
	to.digits[bcd_pos] = zusammen;
	bcd_pos++;	

    }
    to.len = bcd_pos;

}

int main(int argc, char *argv[])
{
    char telefonnummer[] = {"12#*ab4"};
    int size = sizeof(telefonnummer) / sizeof(telefonnummer[0]);
    BCD ergebnis;
    encode (telefonnummer, size,  ergebnis);
  return EXIT_SUCCESS;
}

Es macht aber leider nicht das was es soll. Ich glaube die Sache mit der ganzen Bitschieberei ist irgendwie falsch. Leider weiß ich nicht was!

Ich denke hier ist schon mal ein Fehler:

case ('c'): {
        return (1+(1<<1)+(1<<2)+(1<<3));
    }

Das ganze müsste wohl eher so

case ('c'): {
        return ((1<<1)+(1<<2)+(1<<3));
    }

lauten, oder?

-- ansonsten... ich hab leider nicht die bcd-kodierung im kopf. deine encode-funktion muss ich mir noch genauer anschauen...

Windalf

ums nur einmal zu diskutieren
http://www.fun-soft.de/showtopic.php?threadid=8259

volkard

deine fehler finden mag ich nicht. der code ist so komisch. hier mal ein vorschlag, wie ich es machen würde. wenn was unklar ist, frag Windalf.

#include <iostream>
#include <stdlib.h>

using namespace std;

int const BCD_LEN=16;

struct BCD{
    int len;
    char digits[BCD_LEN];
};

char nybbleToChar(int i){
    return "0123456789*#abc"[i];
}

int charToNybble(char ch){//vermeidet die lange switch-orgie
    for(char i=0;i<=15;++i)
        if(nybbleToChar(i)==ch)
                return i;
    return -1;
}

BCD encode(char const* str){
    BCD bcd={0};//return value optimization, daher keine zusatzkosten beim rauskopieren
    for(;;){//endlos, weil bedingung nicht harmonisch in die schleife mit zwei 
        //sehr ähnlichen ausgängen passt
       if(*str=='\0') break;
       int nybble1=charToNybble(*str);
       ++str;
       int nybble2=charToNybble(*str);
       bcd.digits[bcd.len]=(nybble1<<4)|nybble2;
       ++bcd.len;
       if(*str=='\0') break;
       ++str;
    }
    return bcd;
}

void decode(BCD const& bcd,char* str){
    for(int i=0;i<bcd.len;++i){
        int nybble1=(unsigned char)bcd.digits[i]>>4;
        *str=nybbleToChar(nybble1);
        ++str;
        int nybble2=bcd.digits[i]&15;
        *str=nybbleToChar(nybble2);
        ++str;
    }
    *str='\0';
}

int main()
{
    BCD bcd=encode("1234*");
    char result[33];
    decode(bcd,result);
    cout<<result<<endl;
    system("PAUSE");	
    return 0;
}

Windalf

@volkard

wenn was unklar ist, frag Windalf.

*rofl* was soll das denn heissen? codekommentierer ist eigenlich nicht mein traumberuf

Ja, das sieht in der Tat besser aus als mein Code !

Auf die Nybbletochar und chartonybble Funktionen wär ich niemals selbst gekommen!

Danke für die Hilfe! Ich versuch das mal für meine vorhandenen Code umzubauen!

metzgerkarl

Hi,

derUnregistrierte, ich komme mit deinen Beschreibungen kein Furz hin!! Kannst du das vllt mal ein klitzeklienes bisschen benauer Erläutern, oder ist das bei dir net möglich???? Wäre auf jeden Fall klasse, MERCI!!!

Großes Problem mit Aufgabe (Umwandlung String -&gt; TBCD String) *heul*

Aufgabenstellung:

Erklärung:

Großes Problem mit Aufgabe (Umwandlung String -> TBCD String) heul