Solidity

Operators

Solidity supports the following groups of operators:

• Arithmetic Operators
• Assignment (and compound assignment) Operators
• Relational (comparison) Operators
• Logical Operators
• Bitwise and Shift Operators
• Ternary (conditional) Operator

Arithmetic Operators

Arithmetic operators perform mathematical operations on integers. Solidity has no floating-point numbers, so all results are whole numbers.

Checked arithmetic (Solidity 0.8 and later)

• If a result goes outside the type’s range – e.g. uint8(255) + 1 or 0 - 1 for a uint – the transaction reverts with a Panic error instead of silently wrapping around.
• Division or modulus by zero also reverts.
• Inside an unchecked { ... } block the checks are switched off and values wrap around (255 + 1 becomes 0). Use it only when you are sure overflow cannot happen, to save gas.
• With signed integers, -7 / 2 = -3 and -7 % 2 = -1 (the remainder takes the sign of the left operand).

Assignment Operators

Assignment operators store a value in a variable; compound forms shorten common updates.

The delete operator resets a variable to its default value (e.g. delete count; sets it to 0).

Relational Operators

Relational operators compare two values and return a bool.

Strings cannot be compared with ==; compare their hashes instead (Chapter 9).

Logical Operators

Short-circuit: in a && b, if a is false, b is not evaluated; in a || b, if a is true, b is not evaluated. Putting the cheaper check first can save gas.

Ternary Operator

A short form of a simple if/else that returns one of two values:

condition ? valueIfTrue : valueIfFalse
uint larger = (a > b) ? a : b;

Bitwise and Shift Operators

Bitwise operators work on the individual bits (0 and 1) of integers. Example with a = 12 (binary 1100) and b = 10 (binary 1010):

Example : Operators in a Contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract OperatorsDemo {
    function arithmetic(uint a, uint b) public pure
        returns (uint sum, uint diff, uint product, uint quotient, uint remainder, uint power)
    {
        sum = a + b;
        diff = a - b;            // reverts if b > a (checked arithmetic)
        product = a * b;
        quotient = a / b;        // reverts if b == 0
        remainder = a % b;
        power = a ** 2;
    }

    function compare(uint a, uint b) public pure returns (bool equal, bool bothPositive, uint larger) {
        equal = (a == b);
        bothPositive = (a > 0 && b > 0);
        larger = (a > b) ? a : b;        // ternary operator
    }

    function bitwise(uint8 a, uint8 b) public pure returns (uint8, uint8, uint8, uint8) {
        return (a & b, a | b, a ^ b, a << 1);
    }

    function wrapAround() public pure returns (uint8) {
        uint8 x = 255;
        unchecked { x = x + 1; }        // no overflow check: wraps to 0
        return x;
    }
}

Key Takeaways

The PDF E-Notes are the earlier printable version of this chapter. The notes on this page are the latest, revised version.

Question / Answer (15 questions)

MCQ Test : Check Your Understanding (5 questions)

Select an option and press Check Answer, or answer all questions and press Submit Test to see your score. Each answer comes with an explanation.

Bibliography/References

The notes, questions and MCQs on this page are original explanations written for this course. The works listed below were consulted and are cited for attribution and further reading. Product names, logos and trademarks belong to their respective owners. Short quotations, where used, are marked and attributed.

1. Solidity Team. (n.d.). Types (value types, reference types, mappings, operators, conversions). Solidity Documentation. https://docs.soliditylang.org/en/latest/types.html
2. Solidity Team. (n.d.). Expressions and Control Structures (if/else, loops, checked arithmetic, error handling, try/catch). Solidity Documentation. https://docs.soliditylang.org/en/latest/control-structures.html
3. Solidity Team. (n.d.). Cheatsheet. Solidity Documentation. https://docs.soliditylang.org/en/latest/cheatsheet.html
4. CoinsBench. (n.d.). Solidity #4: Operators & Conditions. https://coinsbench.com/solidity-4-operators-conditions-736a2c3faeff
5. Modi, R. (2018). Solidity Programming Essentials: A beginner’s guide to build smart contracts for Ethereum and blockchain. Packt Publishing. ISBN 978-1-78883-138-3.