Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
24.07.2004, 12:06 Uhr
~metzgerkarl
Gast

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:

C++:

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.

Bearbeitung von Pablo:

CPP tags eingefügt

Dieser Post wurde am 24.07.2004 um 12:49 Uhr von Pablo editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
24.07.2004, 12:12 Uhr
FloSoft
Medialer Over-Flow
(Administrator)

Hausaufgaben werden nicht gemacht, ohne eigenen Ansatz wird dir keiner helfen
--
class God : public ChuckNorris { };

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
24.07.2004, 13:53 Uhr
~metzgerkarl
Gast

Ja so war es auch nicht gedacht. Also bis jetzt hab ich mir folgendes überlegt:

C++:

#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!

Dieser Post wurde am 24.07.2004 um 13:59 Uhr von Windalf editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

003
24.07.2004, 14:09 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)

bleibt die frage offen was machst du wenn die telefonnummer kürzer als 16 zeichen ist?
nullst du vorne alles und hängst hinten die nummer ran?
also wenn du z.b. 12#*ab4 hast was ja 7 zeichen sind (wofür du dann ja nur 3 1/2 bytes bräuchtest) was machst du mit den anderen 12 1/2? vorne nullen oder hinten nullen...

und das mit dem füllzeichen ist mir auch nicht so ganz klar ... also das mit dem 1111...
wo wird denn da nun gefüllt, in dem beispiel mit den 7 zeichen ist ja ungerade, soll vorne die 1111 rangehangen werden oder in unserem beispiel hinten?

schrieb mir mal in hexform auf wie dein 12#*ab4 in 16byte form aussehen soll...

ich vermute ja so aber man weiss ja nie

00 00 00 00 00 00 00 00 00 00 00 00 F1 2B AC D4
--
...fleißig wie zwei Weißbrote

Dieser Post wurde am 24.07.2004 um 14:23 Uhr von Windalf editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: