C Language
Implicita och explicita konverteringar

Syntax

• Explicit Conversion (alias "Casting"): (typ) uttryck

Anmärkningar

Heltalsomvandlingar i funktionssamtal

Med tanke på att funktionen har en korrekt prototyp utvidgas heltal för samtal till funktioner enligt reglerna för heltalskonvertering, C11 6.3.1.3.

6.3.1.3 Signerade och osignerade heltal
När ett värde med heltalstyp konverteras till en annan heltalstyp än _Bool, om värdet kan representeras av den nya typen, är det oförändrat.

Annars, om den nya typen inte är signerad, konverteras värdet genom att flera gånger lägga till eller subtrahera ett mer än det maximala värdet som kan representeras i den nya typen tills värdet ligger inom området för den nya typen.

Annars är den nya typen signerad och värdet kan inte representeras i den; antingen är resultatet implementeringsdefinerat eller en implementeringsdefinierad signal lyftes.

Vanligtvis bör du inte avkorta en bred signerad typ till en smalare signerad typ, för uppenbarligen kan värdena inte passa och det finns ingen tydlig mening att detta borde ha. C-standarden som nämns ovan definierar dessa fall för att vara "implementeringsdefinerade", det vill säga de är inte bärbara.

Följande exempel antar att int är 32 bitars bredt.

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

Pekarkonverteringar i funktionssamtal

Pekarkonverteringar till void* är implicita, men alla andra pekarkonvertering måste vara uttryckliga. Medan kompilatorn tillåter en uttrycklig konvertering från vilken som helst pekare-till-datatyp till någon annan pekare-till-datatyp, är åtkomst till ett objekt genom en felaktigt markerad pekare felaktigt och leder till odefinierat beteende. Det enda fallet som dessa är tillåtna är om typerna är kompatibla eller om pekaren som du tittar på objektet är en karaktärstyp.

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