Variable Types & Storage

Memory Allocation for Different Data Types — Watch how the compiler allocates different amounts of memory for each data type and stores values using different binary representations.

#include <iostream>
#include <iomanip>
using namespace std;

int main() {
    // Declare variables of each fundamental type
    int age = 25;
    char grade = 'A';
    float height = 5.9f;   // 'f' suffix for float literal
    double pi = 3.14159265358979;
    
    // Print values
    cout << "Age: " << age << endl;
    cout << "Grade: " << grade << endl;
    cout << "Height: " << fixed << setprecision(6) << height << endl;
    cout << "Pi: " << fixed << setprecision(6) << pi << endl;
    
    // Print sizes using sizeof
    cout << "\nSize of int: " << sizeof(int) << " bytes" << endl;
    cout << "Size of char: " << sizeof(char) << " byte" << endl;
    cout << "Size of float: " << sizeof(float) << " bytes" << endl;
    cout << "Size of double: " << sizeof(double) << " bytes" << endl;
    
    return 0;
}

import sys

# Python is dynamically typed — no explicit type declarations needed
age = 25           # int
grade = 'A'        # str (Python has no char type)
height = 5.9       # float (Python floats are double-precision)
pi = 3.14159265358979  # float (same precision as C's double)

# Print values
print(f"Age: {age}")
print(f"Grade: {grade}")
print(f"Height: {height:.6f}")
print(f"Pi: {pi:.6f}")

# Print sizes using sys.getsizeof()
# Note: Python object sizes include overhead (type info, reference count)
print(f"\nSize of int: {sys.getsizeof(age)} bytes")
print(f"Size of str: {sys.getsizeof(grade)} bytes")
print(f"Size of float: {sys.getsizeof(height)} bytes")

# Check types dynamically
print(f"\nType of age: {type(age)}")
print(f"Type of grade: {type(grade)}")
print(f"Type of height: {type(height)}")

public class Solution {
    public static void main(String[] args) {
        // Declare variables of each primitive type
        int age = 25;
        char grade = 'A';
        float height = 5.9f;   // 'f' suffix for float literal
        double pi = 3.14159265358979;
        
        // Print values
        System.out.println("Age: " + age);
        System.out.println("Grade: " + grade);
        System.out.printf("Height: %.6f%n", height);
        System.out.printf("Pi: %.6f%n", pi);
        
        // Java has fixed sizes (platform-independent)
        System.out.println("\nSize of int: " + Integer.BYTES + " bytes");
        System.out.println("Size of char: " + Character.BYTES + " bytes");
        System.out.println("Size of float: " + Float.BYTES + " bytes");
        System.out.println("Size of double: " + Double.BYTES + " bytes");
        
        // Print ranges
        System.out.println("\nInt range: " + Integer.MIN_VALUE + " to " + Integer.MAX_VALUE);
    }
}

Type Conversions — Implicit Promotion and Explicit Casting — Watch how values change when converting between types: integer division truncates, casting to double preserves precision, and narrowing conversions lose data.

#include <iostream>
#include <iomanip>
using namespace std;

int main() {
    // Integer division vs floating-point division
    int a = 5, b = 2;
    cout << "Integer division: " << a << " / " << b << " = " << (a / b) << endl;
    cout << "Float division: " << a << " / " << b << " = " << ((double)a / b) << endl;
    
    // Narrowing conversion: double to int
    double temperature = 36.7;
    int temp_int = (int)temperature;
    cout << "\nDouble: " << temperature << " -> Int: " << temp_int << " (truncated)" << endl;
    
    // Char as integer
    char ch = 'A';
    int ascii = ch;  // Implicit promotion
    cout << "\nChar: " << ch << " -> ASCII: " << ascii << endl;
    cout << "Next char: " << (char)(ch + 1) << " (ASCII " << (ch + 1) << ")" << endl;
    
    // Float vs double precision
    double precise = 1.23456789012345;
    float less_precise = (float)precise;
    cout << "\nDouble: " << fixed << setprecision(15) << precise << endl;
    cout << "Float:  " << fixed << setprecision(15) << less_precise << endl;
    
    return 0;
}

# Python handles types differently than C — it's dynamically typed
# and has arbitrary-precision integers

# Integer division vs float division
a = 5
b = 2
print(f"Integer division: {a} // {b} = {a // b}")  # Floor division: 2
print(f"Float division: {a} / {b} = {a / b}")       # True division: 2.5

# Type conversion (explicit)
temperature = 36.7
temp_int = int(temperature)  # Truncates toward zero
print(f"\nFloat: {temperature} -> Int: {temp_int} (truncated)")

# Character and ASCII
ch = 'A'
ascii_val = ord(ch)  # ord() gives ASCII value
print(f"\nChar: {ch} -> ASCII: {ascii_val}")
next_ch = chr(ascii_val + 1)  # chr() converts back to character
print(f"Next char: {next_ch} (ASCII {ascii_val + 1})")

# Python floats are always double-precision (64-bit)
import struct
f_val = 1.23456789012345
# Pack as float (32-bit) then unpack to see precision loss
f_as_32bit = struct.unpack('f', struct.pack('f', f_val))[0]
print(f"\nDouble precision: {f_val:.15f}")
print(f"Float precision:  {f_as_32bit:.15f}")

# Dynamic typing demo
x = 42
print(f"\nType of x: {type(x)}")  # <class 'int'>
x = 3.14
print(f"Type of x: {type(x)}")    # <class 'float'> — type changed!

public class Solution {
    public static void main(String[] args) {
        // Integer division vs floating-point division
        int a = 5, b = 2;
        System.out.println("Integer division: " + a + " / " + b + " = " + (a / b));
        System.out.println("Float division: " + a + " / " + b + " = " + ((double) a / b));
        
        // Narrowing conversion: double to int (requires explicit cast)
        double temperature = 36.7;
        int tempInt = (int) temperature;
        System.out.println("\nDouble: " + temperature + " -> Int: " + tempInt + " (truncated)");
        
        // Char as integer
        char ch = 'A';
        int ascii = ch;  // Implicit widening
        System.out.println("\nChar: " + ch + " -> ASCII: " + ascii);
        System.out.println("Next char: " + (char)(ch + 1) + " (ASCII " + (ch + 1) + ")");
        
        // Float vs double precision
        double precise = 1.23456789012345;
        float lessPrecise = (float) precise;  // Explicit narrowing
        System.out.printf("\nDouble: %.15f%n", precise);
        System.out.printf("Float:  %.15f%n", lessPrecise);
        
        // Integer overflow demonstration
        int maxInt = Integer.MAX_VALUE;
        System.out.println("\nMax int: " + maxInt);
        System.out.println("Max int + 1: " + (maxInt + 1));  // Overflow!
    }
}

Integer Overflow and Unsigned Wrapping — Watch what happens at the bit level when a value exceeds a type's maximum: signed integers flip from positive to negative, and unsigned integers wrap around to zero.

#include <iostream>
#include <limits>
#include <iomanip>
using namespace std;

int main() {
    // Type modifiers demonstration
    short s = 32767;            // 2 bytes, max signed value
    long long ll = 9223372036854775807LL; // 8 bytes
    unsigned int u = 4294967295U;          // 4 bytes, max unsigned
    
    cout << "=== Type Sizes and Ranges ===" << endl;
    cout << "short: " << sizeof(short) << " bytes, max: " << SHRT_MAX << endl;
    cout << "int: " << sizeof(int) << " bytes, max: " << INT_MAX << endl;
    cout << "long long: " << sizeof(long long) << " bytes, max: " << LLONG_MAX << endl;
    cout << "unsigned int: " << sizeof(unsigned int) << " bytes, max: " << UINT_MAX << endl;
    
    // Signed overflow (undefined behavior in C/C++!)
    cout << "\n=== Signed Overflow ===" << endl;
    short before = s;
    s = s + 1;  // UB in theory, wraps in practice
    cout << "short: " << before << " + 1 = " << s << endl;
    
    // Unsigned wrapping (well-defined)
    cout << "\n=== Unsigned Wrapping ===" << endl;
    unsigned char uc = 255;
    unsigned char after = uc + 1;
    cout << "unsigned char: " << (int)uc << " + 1 = " << (int)after << endl;
    
    // Float vs double precision
    cout << "\n=== Float vs Double Precision ===" << endl;
    float f = 16777217.0f;
    double d = 16777217.0;
    cout << fixed << setprecision(1);
    cout << "float stores 16777217 as: " << f << endl;
    cout << "double stores 16777217 as: " << d << endl;
    
    // Signed vs unsigned interpretation
    cout << "\n=== Same Bits, Different Interpretation ===" << endl;
    signed char sc = -1;             // bits: 11111111
    unsigned char uc2 = (unsigned char)sc;  // same bits: 11111111 = 255
    cout << "signed char: " << (int)sc << " -> unsigned: " << (int)uc2 << endl;
    
    return 0;
}

import sys
import struct

# Python's int has arbitrary precision — no overflow!
print("=== Python Integer: No Overflow ===")
huge = 2 ** 100  # This would overflow ANY C integer type
print(f"2^100 = {huge}")
print(f"Digits: {len(str(huge))}")

# But floats DO have limits (they are C doubles internally)
print("\n=== Float Precision Limits ===")
f1 = 16777217.0
print(f"16777217 as float: {f1}")  # Python float is double-precision

# Demonstrate precision loss using struct (simulating C float)
f_packed = struct.pack('f', 16777217.0)
f_unpacked = struct.unpack('f', f_packed)[0]
print(f"As C float (32-bit): {f_unpacked:.1f}")  # 16777216.0 — lost 1!
print(f"As C double (64-bit): {16777217.0:.1f}")  # 16777217.0 — exact

# Simulating signed vs unsigned interpretation
print("\n=== Signed vs Unsigned Bits ===")
signed_val = -1
# In C, signed char -1 has bits 11111111
# As unsigned: those same bits = 255
unsigned_val = signed_val & 0xFF  # Mask to 8 bits
print(f"Signed: {signed_val} -> Unsigned (8-bit): {unsigned_val}")

# Python's dynamic typing
print("\n=== Dynamic Typing ===")
x = 42
print(f"x = {x}, type: {type(x).__name__}")
x = 3.14
print(f"x = {x}, type: {type(x).__name__}")
x = 'hello'
print(f"x = {x}, type: {type(x).__name__}")

# Type checking and conversion
print("\n=== Type Conversion ===")
print(f"int(3.7) = {int(3.7)}")       # Truncates: 3
print(f"float(5) = {float(5)}")       # Widens: 5.0
print(f"int('42') = {int('42')}")     # String to int: 42
print(f"str(100) = '{str(100)}'")     # Int to string: '100'

public class Solution {
    public static void main(String[] args) {
        // Java has fixed-size types (platform-independent)
        System.out.println("=== Java Type Sizes and Ranges ===");
        System.out.println("byte:  " + Byte.BYTES + " byte,  range: " + Byte.MIN_VALUE + " to " + Byte.MAX_VALUE);
        System.out.println("short: " + Short.BYTES + " bytes, range: " + Short.MIN_VALUE + " to " + Short.MAX_VALUE);
        System.out.println("int:   " + Integer.BYTES + " bytes, range: " + Integer.MIN_VALUE + " to " + Integer.MAX_VALUE);
        System.out.println("long:  " + Long.BYTES + " bytes, range: " + Long.MIN_VALUE + " to " + Long.MAX_VALUE);
        System.out.println("float: " + Float.BYTES + " bytes");
        System.out.println("double: " + Double.BYTES + " bytes");
        
        // Signed overflow (wraps silently in Java)
        System.out.println("\n=== Signed Overflow ===");
        short s = 32767;
        s++;  // Wraps to -32768
        System.out.println("short 32767 + 1 = " + s);
        
        int maxInt = Integer.MAX_VALUE;
        System.out.println("int " + maxInt + " + 1 = " + (maxInt + 1));
        
        // Float vs double precision
        System.out.println("\n=== Float vs Double Precision ===");
        float f = 16777217.0f;
        double d = 16777217.0;
        System.out.printf("float stores 16777217 as: %.1f%n", f);   // 16777216.0
        System.out.printf("double stores 16777217 as: %.1f%n", d);  // 16777217.0
        
        // Char in Java is unsigned 16-bit (Unicode)
        System.out.println("\n=== Java char (16-bit Unicode) ===");
        char ch = 'A';
        int ascii = ch;
        System.out.println("char '" + ch + "' = " + ascii + " (Unicode/ASCII)");
        System.out.println("Next: '" + (char)(ch + 1) + "'");
        
        // Autoboxing and wrapper types
        System.out.println("\n=== Wrapper Types ===");
        Integer boxed = 42;  // Autoboxing: int -> Integer
        int unboxed = boxed; // Unboxing: Integer -> int
        System.out.println("Boxed: " + boxed + ", Unboxed: " + unboxed);
    }
}