C Language
Impliciete en expliciete conversies

Syntaxis

• Expliciete conversie (aka "Casting"): (type) expressie

Opmerkingen

Integer-conversies in functie-oproepen

Gezien het feit dat de functie een goed prototype heeft, worden gehele getallen verbreed voor aanroepen van functies volgens de regels voor de conversie van gehele getallen, C11 6.3.1.3.

6.3.1.3 Getekende en niet-ondertekende gehele getallen
Wanneer een waarde met het type geheel getal wordt geconverteerd naar een ander geheel getaltype anders dan _Bool en de waarde kan worden weergegeven door het nieuwe type, blijft deze ongewijzigd.

Anders wordt, als het nieuwe type niet is ondertekend, de waarde geconverteerd door herhaaldelijk één meer toe te voegen of af te trekken dan de maximale waarde die in het nieuwe type kan worden weergegeven totdat de waarde binnen het bereik van het nieuwe type valt.

Anders wordt het nieuwe type ondertekend en kan de waarde er niet in worden weergegeven; of het resultaat is door de implementatie gedefinieerd of een door de implementatie gedefinieerd signaal wordt weergegeven.

Meestal moet u een breed ondertekend type niet inkorten naar een smaller ondertekend type, omdat de waarden uiteraard niet passen en er geen duidelijke betekenis is die dit zou moeten hebben. De hierboven aangehaalde C-standaard definieert deze gevallen als "door de implementatie gedefinieerd", dat wil zeggen dat ze niet draagbaar zijn.

Het volgende voorbeeld veronderstelt dat int 32 bit breed is.

#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;
}

Aanwijzerconversies in functie-oproepen

Wijzerconversies naar void* zijn impliciet, maar elke andere pointerconversie moet expliciet zijn. Hoewel de compiler een expliciete conversie mogelijk maakt van elk aanwijzer-naar-gegevenstype naar een ander aanwijzer-naar-gegevenstype, is de toegang tot een object via een verkeerd getypte aanwijzer onjuist en leidt tot ongedefinieerd gedrag. Het enige geval dat deze zijn toegestaan, is als de typen compatibel zijn of als de aanwijzer waarmee u naar het object kijkt, een karaktertype is.

#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;
}