C Language
Implizite und explizite Konvertierungen

Syntax

• Explizite Konvertierung (auch bekannt als "Casting"): (Typ) Ausdruck

Bemerkungen

Ganzzahlkonvertierungen in Funktionsaufrufen

Da die Funktion über einen geeigneten Prototyp verfügt, werden Ganzzahlen für Aufrufe von Funktionen nach den Regeln der Ganzzahlkonvertierung erweitert. C11 6.3.1.3.

6.3.1.3 Vorzeichenbehaftete und vorzeichenlose Ganzzahlen
Wenn ein Wert mit dem ganzzahligen Typ in einen anderen ganzzahligen Typ als _Bool konvertiert wird, bleibt der Wert unverändert, wenn der Wert durch den neuen Typ dargestellt werden kann.

Wenn der neue Typ nicht vorzeichenbehaftet ist, wird der Wert ansonsten konvertiert, indem wiederholt ein Wert mehr als der Maximalwert hinzugefügt oder subtrahiert wird, der im neuen Typ dargestellt werden kann, bis der Wert im Bereich des neuen Typs liegt.

Andernfalls ist der neue Typ vorzeichenbehaftet und der Wert kann nicht darin dargestellt werden. Entweder ist das Ergebnis implementierungsdefiniert oder ein implementierungsdefiniertes Signal wird ausgelöst.

Normalerweise sollten Sie einen Wide-Signed-Typ nicht auf einen engeren Signaltyp abschneiden, da die Werte offensichtlich nicht passen und es keine eindeutige Bedeutung für diesen Wert gibt. Der oben zitierte C-Standard definiert diese Fälle als "implementierungsdefiniert", das heißt, sie sind nicht portierbar.

Im folgenden Beispiel wird angenommen, dass int 32 Bit breit ist.

#include <stdio.h>
#include <stdint.h>

void param_u8(uint8_t val) {
    printf("%s val is %d\n", __func__, val);  /* val is promoted to int */
}

void param_u16(uint16_t val) {
    printf("%s val is %d\n", __func__, val);  /* val is promoted to int */
}

void param_u32(uint32_t val) {
    printf("%s val is %u\n", __func__, val);  /* here val fits into unsigned */
}

void param_u64(uint64_t val) {
    printf("%s val is " PRI64u "\n", __func__, val); /* Fixed with format string */
}

void param_s8(int8_t val) {
    printf("%s val is %d\n", __func__, val);  /* val is promoted to int */
}

void param_s16(int16_t val) {
    printf("%s val is %d\n", __func__, val);  /* val is promoted to int */
}

void param_s32(int32_t val) {
    printf("%s val is %d\n", __func__, val); /* val has same width as int */
}

void param_s64(int64_t val) {
    printf("%s val is " PRI64d "\n", __func__, val); /* Fixed with format string */
}

int main(void) {

    /* Declare integers of various widths */
    uint8_t  u8  = 127;
    uint8_t  s64  = INT64_MAX;

    /* Integer argument is widened when function parameter is wider */
    param_u8(u8);   /* param_u8 val is 127 */
    param_u16(u8);  /* param_u16 val is 127 */
    param_u32(u8);  /* param_u32 val is 127 */
    param_u64(u8);  /* param_u64 val is 127 */
    param_s8(u8);   /* param_s8 val is 127 */
    param_s16(u8);  /* param_s16 val is 127 */
    param_s32(u8);  /* param_s32 val is 127 */
    param_s64(u8);  /* param_s64 val is 127 */

    /* Integer argument is truncated when function parameter is narrower */
    param_u8(s64);  /* param_u8 val is 255 */
    param_u16(s64); /* param_u16 val is 65535 */
    param_u32(s64); /* param_u32 val is 4294967295 */
    param_u64(s64); /* param_u64 val is 9223372036854775807 */
    param_s8(s64);  /* param_s8 val is implementation defined */
    param_s16(s64); /* param_s16 val is implementation defined */
    param_s32(s64); /* param_s32 val is implementation defined */
    param_s64(s64); /* param_s64 val is 9223372036854775807 */

    return 0;
}

Zeigerkonvertierungen in Funktionsaufrufen

Zeigerkonvertierungen in void* sind implizit, aber jede andere Zeigerkonvertierung muss explizit sein. Während der Compiler eine explizite Konvertierung von einem beliebigen Zeiger-zu-Datentyp in einen anderen Zeiger-zu-Datentyp erlaubt, ist der Zugriff auf ein Objekt über einen falsch typisierten Zeiger fehlerhaft und führt zu undefiniertem Verhalten. Diese sind nur zulässig, wenn die Typen kompatibel sind oder wenn der Zeiger, mit dem Sie das Objekt betrachten, ein Zeichentyp ist.

#include <stdio.h>

void func_voidp(void* voidp) {
    printf("%s Address of ptr is %p\n", __func__, voidp);
}

/* Structures have same shape, but not same type */
struct struct_a {
    int a;
    int b;
} data_a;

struct struct_b {
    int a;
    int b;
} data_b;

void func_struct_b(struct struct_b* bp) {
    printf("%s Address of ptr is %p\n", __func__, (void*) bp);
}

int main(void) {


    /* Implicit ptr conversion allowed for void* */
    func_voidp(&data_a);

    /*
     * Explicit ptr conversion for other types
     *
     * Note that here although the have identical definitions,
     * the types are not compatible, and that the this call is
     * erroneous and leads to undefined behavior on execution.
     */
    func_struct_b((struct struct_b*)&data_a);

    /* My output shows: */
    /* func_charp Address of ptr is 0x601030 */
    /* func_voidp Address of ptr is 0x601030 */
    /* func_struct_b Address of ptr is 0x601030 */

    return 0;
}