Wie konvertieren von integer zu unsigned char in C, gegeben ganze zahlen größer als 256?

Als Teil meiner CS habe mir natürlich schon einige Funktionen zu verwenden. Eine dieser Funktionen einen Zeiger auf unsigned chars zu schreiben, Daten in eine Datei (ich habe diese Funktion zu nutzen, so kann ich nicht nur meine eigenen Zwecke gebaut Funktion, die anders funktioniert, BTW). Ich muss schreiben, die ein array von ganzen zahlen, deren Werte können bis zu 4095 Byte über diese Funktion (das dauert nur vorzeichenlose chars).

Allerdings bin ich Recht in der Annahme, dass ein unsigned char kann nur ein max Wert von 256, denn es ist 1 byte lang ist? Deshalb brauche ich auch mit 4 unsigned chars für jede ganze Zahl? Aber Gießen scheint nicht zu funktionieren mit größeren Werte für die ganze Zahl. Hat jemand eine Idee, wie man am besten die Umwandlung einer Integer-array in unsigned chars?

Zählen Sie die Anzahl der bits, die Sie brauchen, um zu repräsentieren 4095. Es ist nicht 4-Byte-Wert.
Auch die Funktion Prototyp in deiner Frage; wird es clerer, was Ihre Zuordnung bestimmten und erhalten Sie eine bessere Antwort.
Aber manchmal ist es einfacher dump sizeof(int) bytes für jede int. Auf diese Weise können Sie führen Sie durch das array die zimmerreserviereung, ohne das einstellen der Zeiger nach jeder Daten-Element, wenn re-Lektüre.

InformationsquelleAutor Alf_InPogform | 2011-01-07

In der Regel ein unsigned char besitzt 8 bits, mit einem max Wert von 255. Wenn Sie wissen wollen, für Ihre speziellen compiler, drucken Sie CHAR_BIT und UCHAR_MAX von <Grenzen.h> ziehen Sie die einzelnen bytes eines 32-bit int,

#include <stdint.h>

void
pack32(uint32_t val,uint8_t *dest)
{
        dest[0] = (val & 0xff000000) >> 24;
        dest[1] = (val & 0x00ff0000) >> 16;
        dest[2] = (val & 0x0000ff00) >>  8;
        dest[3] = (val & 0x000000ff)      ;
}


uint32_t
unpack32(uint8_t *src)
{
        uint32_t val;

        val  = src[0] << 24;
        val |= src[1] << 16;
        val |= src[2] <<  8;
        val |= src[3]      ;

        return val;
}

Sie können drop die wichtigsten 2 bytes von diesem. Der Wert 4095 passt sehr bequem in 16 bits.
Es gibt keine Notwendigkeit zu tun, eine Verarbeitung, um die Werte in ein array von char.
Ein 8-bit-Wert ist der maximale Wert von 2^8 - 1, (d.h. 255), nicht 256. Die Anzahl der insgesamt möglichen Werte ist 256 0 bis 255.

InformationsquelleAutor nos

2

Unsigned char hat in der Regel einen Wert von 1 byte, deshalb können Sie zerlegen jede andere Art, um ein array von unsigned chars (zB. für einen 4-byte-int-Sie können verwenden Sie ein array von 4 unsigned chars). Ihre übung ist wohl über Generika. Schreiben Sie die Datei als eine binäre Datei mit der fwrite () - Funktion, und nur Schreibe byte nach byte in der Datei.

Folgenden Beispiel soll eine Zahl schreiben (eines beliebigen Datentyps) an die Datei. Ich bin mir nicht sicher, ob es funktioniert, da Sie zwingt die cast auf unsigned char * anstelle von void *.
```
int homework(unsigned char *foo, size_t size)
{
    int i;

    //open file for binary writing
    FILE *f = fopen("work.txt", "wb");
    if(f == NULL)
        return 1;

    //should write byte by byte the data to the file
    fwrite(foo+i, sizeof(char), size, f);

    fclose(f);
    return 0;
}
```
Ich hoffe das gegebene Beispiel gibt Ihnen wenigstens einen Ausgangspunkt.

InformationsquelleAutor Chris
0

Ja, du hast Recht; ein char/byte nur erlaubt bis zu 8 verschiedene bits, so dass 2^8 verschiedene zahlen, die von null bis 2^8 - 1 oder null bis 255. So etwas wie dies tun, um die bytes:
```
int x = 0;
char* p = (char*)&x;
for (int i = 0; i < sizeof(x); i++)
{
    //Do something with p[i]
}
```
(Das ist nicht offiziell C wegen der Reihenfolge der Deklaration, aber wie auch immer... es ist mehr lesbar. 🙂 )

Tun, beachten Sie, dass dieser code nicht portabel sein, da kommt es auf die Prozessor-interne Speicher einer int.
- Dies ist die offizielle C, nämlich den aktuellen standard C99.
InformationsquelleAutor Mehrdad
0

Wenn Sie schreiben, die ein array von ganzen zahlen dann nur konvertieren Sie das array in einen Zeiger auf char dann durch das array.
```
int main()
{
    int    data[] = { 1, 2, 3, 4 ,5 };
    size_t size   = sizeof(data)/sizeof(data[0]); //Number of integers.

    unsigned char* out = (unsigned char*)data;
    for(size_t loop =0; loop < (size * sizeof(int)); ++loop)
    {
         MyProfSuperWrite(out + loop);  //Write 1 unsigned char
    }
}
```
Nun, die Menschen haben erwähnt, dass 4096 passen in weniger bits als ein normaler integer. Wohl wahr. So können Sie Platz sparen und nicht schreiben, aus den oberen bits jedes integer. Ich persönlich denke, das ist nicht die Mühe Wert. Den zusätzlichen code zu schreiben, den Wert und die Verarbeitung der eingehenden Daten ist nicht Wert, die Einsparungen, die Sie bekommen würde (Vielleicht, wenn die Daten der Größe der library of congress). Regel eins tun, so wenig Arbeit wie möglich (einfacher zu pflegen). Regel zwei optimieren, wenn Sie gefragt werden (aber Fragen, warum die erste). Sie können Speicherplatz sparen, aber es kostet bei der Bearbeitung Zeit und Wartungskosten.
- Beachten Sie, dass dies nicht sicher ist, wenn die Schriftsteller und Leser haben unterschiedliche endian oder sizeof(int) oder andere details über Ihre integer-Darstellung.
- Sorry verfehlt eine Lösung, die auch als endianness oben!
InformationsquelleAutor Martin York
0

Den Teil des Auftrages von: integers whose values can be up to 4095 using this function (that only takes unsigned chars werden sollten, geben Ihnen einen großen Hinweis. 4095 unsigned ist 12 bit.

Können Sie speichern die 12 bits eines 16-bit -short, aber das ist etwas verschwenderisch der Platz-Sie sind nur 12 der 16 bits der kurzen. Da Sie es mit mehr als 1 byte bei der Umwandlung von Zeichen, die Sie möglicherweise benötigen, um mit endian Typ das Ergebnis. Einfachste.

Sie können auch ein bit-Feld oder einige verpackte binäre Struktur, wenn Sie besorgt sind über den Raum. Mehr Arbeit.

InformationsquelleAutor dawg
0

Es klingt wie das, was Sie wirklich wollen, zu tun ist, rufen sprintf um eine string-Darstellung des Integer-zahlen. Dies ist ein standard-Weg, um die Konvertierung von numerischen Typs in seine Zeichenfolgendarstellung. So etwas wie die folgenden, könnten Sie loslegen können:
```
char num[5]; //Room for 4095

//Array is the array of integers, and arrayLen is its length
for (i = 0; i < arrayLen; i++)
{
    sprintf (num, "%d", array[i]);

    //Call your function that expects a pointer to chars
    printfunc (num);
}
```
- Dies hängt davon ab, ob Sie gespeichert werden soll int Wert in der Datei ist oder nicht. Wenn Sie die Ausgabe-Datei soll binären Speicher für die Daten, diese werden es nicht tun, aber wenn Sie wollen einfach nur speichern Sie das int in ein lesbares format, das ist in Ordnung.
- sprintf hier erwartet ein null-terminiertes array von Zeichen für "%s" - parameter. Wenn eines der bytes 0 sind, werden diese nicht richtig funktionieren. Es auch nicht funktionieren, denn es wird ablaufen am Ende des Arrays ohne das hinzufügen einer 0 am Ende.
- Mein Fehler - ich meinte das format-string %d.... Bearbeitet zu beheben.
InformationsquelleAutor Beerman006
0

Ohne Informationen über die Funktion, die Sie gerichtet sind, zu verwenden in Bezug auf seine Argumente, Rückgabewert und die Semantik (d.h. die definition der Verhaltens -) es ist schwer zu beantworten. Eine Möglichkeit ist:

Gegeben:
```
void theFunction(unsigned char* data, int size);
```
dann
```
int array[SIZE_OF_ARRAY];
theFunction((insigned char*)array, sizeof(array));
```
oder
```
theFunction((insigned char*)array, SIZE_OF_ARRAY * sizeof(*array));
```
oder
```
theFunction((insigned char*)array, SIZE_OF_ARRAY * sizeof(int));
```
Alle, die übergeben wird, alle Daten zu theFunction(), aber ob das als keinen Sinn macht, hängt davon ab, was theFunction() tut.

InformationsquelleAutor Clifford

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.