Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallIn C, a cast has the form (target_type) expression. It requests a conversion of that expression; it does not rewrite the original object or automatically make unrelated memory safe to access. Use casts for deliberate, valid value or pointer conversions, not to silence warnings.
What a cast does
A cast is an explicit conversion. For example:
int i = 42;
double d = (double)i;d receives a converted floating-point value; i remains an int. Likewise:
double price = 19.99;
int dollars = (int)price; /* fractional part discarded */This is value conversion, not reinterpretation of the original bytes. C defines casts as (type-name) expression; the target must be void or a scalar type, and a cast expression is not an lvalue. See C cast syntax and semantics.
Cast syntax and expression boundaries
A cast applies to the expression immediately after it. Parentheses therefore affect both the result and the operation performed:
#1 Best Overall
- Read Before You Buy — No Video Output: These adapters support charging and USB 2.0 data transfer, but cannot transmit video signals. Except for standard USB webcams (which use USB data only), they are not compatible with HDMI/DisplayPort cables, video-capable USB-C hubs, or docking stations with video output.
- Convert USB-A Ports to USB-C: Designed to connect USB-C earphones, cables, flash drives, card readers, and other USB-C accessories to standard USB-A ports. Plug-and-play with no drivers or software required.
- Aluminum Alloy Housing: Built with a sturdy aluminum alloy shell that aids in heat dissipation and protects against daily wear and scratches. Designed to maintain a stable and secure connection.
- Compact & Travel-Friendly: The ultra-compact design allows the adapter to stay plugged into your device without blocking adjacent ports or adding bulk, reducing wear and tear on your original USB ports.
- 12-Month Warranty: Backed by a 12-month manufacturer warranty for peace of mind. Designed to meet strict quality control standards for reliable everyday performance.
int a = 5;
int b = 2;
double x = a / b; /* 2.0: integer division first */
double y = (double)a / b; /* 2.5: floating-point division */
double z = (double)(a / b); /* 2.0: converts the truncated result */Use a cast when it communicates the intended arithmetic type. If changing a declaration or function signature expresses the intent more accurately, prefer that instead.
Implicit conversions: when C converts without a cast
C performs conversions in contexts such as assignment and initialization, function arguments and return values, arithmetic and comparisons, conditional expressions, and pointer qualification changes. Integer promotions and the usual arithmetic conversions also apply. Arrays commonly convert to pointers in expressions, and function designators convert to function pointers.
long total = 1000; /* assignment conversion */
double average = (double)total / 3.0;
void use_long(long n);
use_long(10); /* int argument converted to long */These rules are detailed in C’s implicit-conversion reference. They do not mean that every incompatible pointer can be converted implicitly or safely.
Promotions and plain char
char c = 200;
int i = c; /* c is promoted before assignment */Whether plain char is signed or unsigned is implementation-defined. Consequently, storing 200 in a plain char and then promoting it can produce different results on different implementations. Use an explicitly signed or unsigned type when the range matters.
Numeric casts
Widening integer conversions
int small = 100;
long large = (long)small;If the destination can represent the source value, the value is preserved. A cast can still be unnecessary when assignment already performs the same conversion.
Narrowing integer conversions
int value = 300;
unsigned char byte = (unsigned char)value;Narrowing can lose range or information. Exact results depend on the destination type and the applicable C conversion rule; do not assume every out-of-range conversion has the same wraparound behavior. Check ranges before converting when correctness matters.
Rank #2
- 5-in-1 USB-C Hub: Experience comprehensive connectivity featuring a Power Delivery input, two USB-A 2.0 ports, a USB-A 3.0 port, and an HDMI port. (Note: The USB-C power delivery input port is only for connecting an external wall charger to power your laptop and cannot power peripheral devices.)
- 90W Pass-Through Charging: Achieve optimal charging with 90W pass-through power to your laptop, supported by a total input of 100W, with the hub reserving 10W for operational efficiency. (Note: Wall charger not included.)
- Quick Data Transfers: Accelerate your productivity with rapid data transfers using a high-speed 5Gbps USB 3.0 port and two 480Mbps USB 2.0 ports.
- 4K HDMI Display: Enhance your visual experience with a hub capable of delivering 4K resolution at 30Hz in both mirror and extend modes. Please note that this hub is compatible with MacBook (macOS 12 and newer), Windows 10 and 11, ChromeOS, and laptops equipped with DP Alt Mode and Power Delivery. Note: This device is not compatible with Linux.
- What You Get: Anker USB-C Hub (5-in-1, 4K HDMI), welcome guide, 18-month warranty, and our friendly customer service.
Signed and unsigned arithmetic
int s = -1;
unsigned int u = 1;
if (s < u) {
/* The usual arithmetic conversions may produce a surprise. */
}The comparison can be surprising even though no explicit cast appears: the signed operand may be converted to unsigned. A cast can document intent, but choosing the wrong destination type can hide rather than fix a bug.
Floating-point and integer conversions
int i = (int)3.9; /* 3 when representable */
double d = (double)7; /* 7.0 */
int n = (int)-3.9; /* -3 when representable */For a representable floating-to-integer result, the fractional part is discarded toward zero. An out-of-range floating-to-integer conversion must not be treated as safe clamping or wrapping. Validate the range first. Converting a wide floating type to a narrower one can lose precision or range:
Free tools Windows power users keep installed
One-click scans. No signup required.
float f = (float)very_large_double;Conversely, converting an integer to double does not guarantee that every large integer remains exact.
Pointer casts: conversion is not permission to dereference
A pointer cast changes the pointer expression's type. It does not change the pointed-to object's declared type, alignment, lifetime, or representation. Analyze the conversion and any later dereference separately.
Object pointers and void *
int value = 42;
void *p = &value;
int *ip = p; /* implicit conversion is permitted in C */
printf("%dn", *ip);An explicit cast is usually redundant:
int *ip = (int *)p;This is valid only when p actually points to an int object (or an object validly accessible as one) and the resulting pointer is used appropriately. A void * is not a license to cast any address to any unrelated type.
Unrelated object pointers
float f = 1.0f;
int *ip = (int *)&f;
printf("%dn", *ip);The cast may compile, but the dereference can be invalid for several independent reasons:
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Rank #3
- Sleek 7-in-1 USB-C Hub: Features an HDMI port, two USB-A 3.0 ports, and a USB-C data port, each providing 5Gbps transfer speeds. It also includes a USB-C PD input port for charging up to 100W and dual SD and TF card slots, all in a compact design.
- Flawless 4K@60Hz Video with HDMI: Delivers exceptional clarity and smoothness with its 4K@60Hz HDMI port, making it ideal for high-definition presentations and entertainment. (Note: Only the HDMI port supports video projection; the USB-C port is for data transfer only.)
- Double Up on Efficiency: The two USB-A 3.0 ports and a USB-C port support a fast 5Gbps data rate, significantly boosting your transfer speeds and improving productivity.
- Fast and Reliable 85W Charging: Offers high-capacity, speedy charging for laptops up to 85W, so you spend less time tethered to an outlet and more time being productive.
- What You Get: Anker USB-C Hub (7-in-1), welcome guide, 18-month warranty, and our friendly customer service.
- The address may not satisfy
int's alignment requirement. - Accessing a
floatobject through an incompatibleintlvalue can violate effective-type and strict-aliasing rules. - The bytes need not represent a valid
int, and a trap representation may be possible.
The C object-model reference explains object representation, effective type, and aliasing constraints. A cast does not override those rules.
Alignment is a separate requirement
unsigned char buffer[sizeof(int)];
int *p = (int *)buffer; /* may be incorrectly aligned */Even on a machine that tolerates unaligned access, the code is not automatically portable. Correct alignment alone would not make an incompatible typed access legal; alignment, effective type, lifetime, and representation are separate concerns.
Inspecting bytes safely
For object-representation inspection, use a character-type pointer:
#include <stdio.h>
#include <stddef.h>
double value = 3.14;
const unsigned char *bytes = (const unsigned char *)&value;
for (size_t i = 0; i < sizeof value; ++i)
printf("%02X ", bytes[i]);Character access is different from dereferencing an unrelated numeric pointer. Byte order and floating-point representation are implementation-dependent, so this output is not a portable serialized format.
To copy an object representation without type-punning through an incompatible lvalue, use memcpy:
#include <string.h>
float f = 3.5f;
unsigned int bits = 0;
_Static_assert(sizeof bits == sizeof f, "sizes must match");
memcpy(&bits, &f, sizeof bits);The resulting integer still depends on representation and byte order. Equal size is necessary for this example, not a guarantee of a portable wire format.
Rank #4
- Dual Converters, Infinite Potential：Includes 2× USB C male to USB A female adapters and 2× USB A male to USB C female adapters. Perfect for a wide range of uses—tablets with Bluetooth keyboards, expand USB ports on macbook, and more. Two different converters for all your daily needs
- Next-Level 10Gbps & 3A Charging: No more slow 480Mbps, this usb to usb c adapter has a transfer speed of up to 10Gbps, allowing you to do more transferring in less time. This usb adapter fits both USB A and USB C charger, supporting up to 3A fast charging
- Upgraded Exquisite Craftsmanship: With an aluminum alloy housing and metal connector, the usbc to usb adapter is extremely durable and sturdy. Rigorously tested to withstand more than 10,000 times of plugging and unplugging, ensuring long-lasting performance
- Broad Compatible: The usb c to usb adapter widely supports all USB C/ USB A devices like laptops, tablets, cellphones, car chargers, and phone chargers. Such as compatible with MacBook Pro/Air 2023/2022, Thunderbolt 4/3 Devices,Apple MagSafe Watch 9/8/7/SE/Ultra, iPad Pro 2022/2021, Samsung Galaxy S23/S20/S10, and iPhone 17/16/15 Pro. Plug and play
- Please Note: To reach 10Gbps speed, keep the cable under 3.3 ft. For USB A Male to USB C adapters, try flipping the USB C connector. USB C Male to USB A adapters support bidirectional 10Gbps transfer within 3.3 ft
Pointer-to-integer and integer-to-pointer casts
These conversions are implementation-defined, not universally portable:
#include <stdint.h>
uintptr_t saved = (uintptr_t)ptr;
void *restored = (void *)saved;uintptr_t, when supplied by the implementation, is intended to hold a converted void *; it is optional. Do not cast pointers to int, assume a pointer is the same size as long, or use raw pointer values as serialized data. The implementation may define a result that is not correctly aligned or does not identify an object of the intended type; failure to represent a pointer-to-integer result can be undefined. See SEI CERT INT36-C guidance. For handles, use the API's documented handle type.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Function-pointer casts
Function pointers are a distinct category from object pointers:
typedef int (*callback_t)(int);
int callback(int x) { return x + 1; }
callback_t f = callback;A function pointer can be converted to another function-pointer type and back, but calling through a pointer whose type is incompatible with the actual function type is undefined behavior. A cast does not make calling conventions, parameter types, return types, variadicness, or ABI attributes compatible. Hazards include passing a non-variadic function where a variadic callback is required, or mismatching return and parameter types. The WG14 material at open-std.org discusses incompatible function-pointer calls. Do not use a cast from a function pointer to void * as generic storage.
Casting away const
void update(char *text);
const char message[] = "hello";
update((char *)message);Removing const from the pointer type does not make the object writable. If the object was defined with const and the called function modifies it, behavior is undefined. Removing the qualifier can be valid when the object was originally non-const, is genuinely writable, and is used consistently. Prefer fixing an API that incorrectly omits const rather than bypassing it with a cast. The distinction is between a discarded type qualifier and the storage properties of the actual object.
Struct and union casts
Structs with similar fields are not automatically interchangeable:
Best Value
- 5-in-1 Connectivity: Equipped with a 4K HDMI port, a 5 Gbps USB-C data port, two 5 Gbps USB-A ports, and a USB C 100W PD-IN port. Note: The USB C 100W PD-IN port supports only charging and does not support data transfer devices such as headphones or speakers.
- Powerful Pass-Through Charging: Supports up to 85W pass-through charging so you can power up your laptop while you use the hub. Note: Pass-through charging requires a charger (not included). Note: To achieve full power for iPad, we recommend using a 45W wall charger.
- Transfer Files in Seconds: Move files to and from your laptop at speeds of up to 5 Gbps via the USB-C and USB-A data ports. Note: The USB C 5Gbps Data port does not support video output.
- HD Display: Connect to the HDMI port to stream or mirror content to an external monitor in resolutions of up to 4K@30Hz. Note: The USB-C ports do not support video output.
- What You Get: Anker 332 USB-C Hub (5-in-1), welcome guide, our worry-free 18-month warranty, and friendly customer service.
struct A { int x; };
struct B { int x; };
struct A a = { 1 };
struct B *bp = (struct B *)&a; /* not a portable conversion */Identical layout in one ABI, or a common first member, does not by itself make access through the other structure type valid. Define an explicit conversion or copy fields. Union type-punning also requires care about the C version, implementation behavior, active-member rules, and object representations; it is not a universal substitute for pointer casting.
Casting malloc results
In C, malloc returns void *, which converts implicitly to an object pointer:
#include <stdlib.h>
int *values = malloc(count * sizeof *values);
if (values == NULL) {
/* allocation failure */
}The casted form is legal but generally unnecessary:
int *values = (int *)malloc(count * sizeof(int));Omitting the cast is idiomatic C and helps expose a missing <stdlib.h> declaration. Using sizeof *values keeps the allocation tied to the pointer's type. Neither form checks multiplication overflow, allocation failure, initialization, or later lifetime errors. A cast cannot repair an under-sized allocation or an invalid alignment assumption.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteWhy casts can hide compiler warnings
This pattern can suppress a useful diagnostic:
int *p = (int *)some_other_pointer;Before adding a cast:
- Read the diagnostic and identify the mismatch.
- Decide whether the goal is value conversion, pointer conversion, or byte inspection.
- Correct the declaration, API, or function signature if possible.
- Add a cast only when the conversion is intentional and valid.
- Record platform or ABI assumptions that cannot be avoided.
- Use warnings and sanitizers during development.
GCC and Clang accept warning options such as:
cc -std=c17 -Wall -Wextra -Wconversion -Wsign-conversion
-Wcast-qual -Wcast-align -Wpedantic file.cThese are compiler-specific options; diagnostics vary by compiler and version.
Choosing the right technique
| Situation | Recommended approach | Main risk |
|---|---|---|
| Integer to floating point | Cast when arithmetic intent needs it | Precision loss for large values |
| Floating point to integer | Validate range, then convert | Fraction and range loss |
void * to an object pointer |
Convert back to the actual pointed-to type | Wrong object type or alignment |
| Inspect raw bytes | Character pointer or memcpy |
Representation and byte order are implementation-dependent |
Remove const |
Avoid; prove the underlying object is writable | Modifying a defined-const object |
| Pointer to integer | Use an implementation-provided suitable type, such as optional uintptr_t |
Loss of information or nonportable representation |
| Function-pointer conversion | Use a compatible function type | Undefined behavior when called incompatibly |
malloc in C |
Omit the cast and use sizeof *ptr |
Allocation, overflow, and lifetime errors remain |
Decision checklist
- Am I converting a value, or trying to reinterpret bytes?
- Can the destination represent the source value?
- Could precision, range, sign, or fractional information be lost?
- Is a pointer correctly aligned?
- Does the pointed-to object really have the destination type or an allowed access type?
- Am I discarding
constfrom an object that may be defined-const? - Am I crossing between object and function-pointer categories?
- Is the conversion implementation-defined or ABI-dependent?
- Would
memcpy, character access, explicit serialization, or an API redesign state the intent more safely?
This guidance targets ISO C as used in C17-era production code, while current references also describe C23 (published as ISO/IEC 9899:2024). Check the standard mode and compiler documentation for version-specific details. C++ named casts such as static_cast and reinterpret_cast are different language features; they are not C syntax. See the C++ cast reference only for that contrast.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
