Dr-Linuxer Blog
Understanding the Integer Data Type in Solidity

Understanding the Integer Data Type in Solidity

Aung Aung Myo Myint's photo
Aung Aung Myo Myint
·

3 min read

Table of contents

In this blog post, we'll look at integer data types in Solidity, which are important for smart contract developers. Solidity has two main types of integers:

  • int: Holds both positive and negative numbers.

  • uint: Holds only positive numbers as it is an unsigned integer.

Let's go through their details, sizes, and how they work, step by step.

Signed vs. Unsigned Integers

  1. Signed Integer (int)

    • Can store both negative and positive values.

    • Example: -5, 0, 10.

  2. Unsigned Integer (uint)

    • Stores only positive values.

    • Example: 0, 5, 100.

Integer Sizes

Both int and uint come in various sizes ranging from 8 bits to 256 bits in increments of 8 (e.g., int8, int16, ..., int256).

  • int8: Can hold values from -128 to 127.

  • uint8: Can hold values from 0 to 255.

The size (e.g., 8 bits) defines the range of numbers the variable can store.

Here’s the formula to calculate the range:

For Signed Integers (int)

Where n is the number of bits.

For Unsigned Integers (uint)

Where n is the number of bits.

Examples:

  • int16: Range is -32,768 to 32,767.

  • uint16: Range is 0 to 65,535.

Default Values

In Solidity, if you declare an integer variable without initializing it, the default value will always be 0. This applies to both int and uint.

Example:

uint public num; // Default value is 0

Int and Uint as Aliases

In Solidity, int and uint are aliases for int256 and uint256, respectively.

Example:

int num = 5;   // Equivalent to int256 num = 5
uint num = 10; // Equivalent to uint256 num = 10

Handling Overflow

Overflow happens when a variable goes beyond its range. Solidity detects overflow at compile time, making smart contracts safer.

Examples:

  1. Signed Integer Overflow

    • int8 can hold values between -128 and 127.

    • Assigning 128 or -129 will result in an error.

    int8 public num = 128; // Compile-time error

  1. Unsigned Integer Overflow

    • uint8 can hold values between 0 and 255.

    • Assigning -1 or 256 will result in an error.

    uint8 public num = 256; // Compile-time error

Practical Example

Let’s see how integers work in Solidity using the Remix IDE.

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;

contract IntegerDemo {
    uint public uintNum = 5;  // Unsigned integer in state variable
    int public intNum = -10; // Signed integer in state variable

    function defaultValues() public pure returns (uint, int) {
        uint defaultUint; // Default value is 0 in local variable
        int defaultInt;   // Default value is 0 in local variable
        return (defaultUint, defaultInt); // Returns 0, 0
    }

    function checkOverflow() public pure returns (uint8, int8) {
        uint8 smallUint = 255; // Maximum value for uint8 in local variable
        int8 smallInt = 127;   // Maximum value for int8 in local variable

        // Uncommenting the lines below would cause compile-time errors
        // uint8 smallUint = 256;  // uint8 overflow
        // int8 smallInt = 128;   // int8 overflow

        return (smallUint, smallInt); // Return the max values for demonstration
    }
}

Key Takeaways

  1. Use uint for numbers that aren't negative and int for numbers that can be negative.

  2. Pick the right bit sizes to save on gas.

  3. Solidity stops overflow errors during compile time, making it safer.

  4. Always test how variables behave in the Remix IDE to know their range and default values.

Understanding integers is important for writing smart contracts that work well and have no errors. Stay tuned for more Solidity tutorials!

Ethereum