Solidity

Struct

• A struct lets you combine several variables of different data types into one new, custom type – a record.
• Think of a struct as a container: when you move the container, everything inside moves with it. A Student struct, for example, can keep a name, roll number and marks together.
• Structs make code more organised and are the usual way to represent records such as candidates, bidders, rides or tickets (see the course projects).
• A struct is a reference type, so in functions it needs a data location (storage or memory).
• A struct cannot contain a member of its own type directly, but it can contain a dynamic array of its own type or be the value of a mapping.

Syntax

struct <StructName> {
    <data type> member1;
    <data type> member2;
}

Where to Declare a Struct

• Inside a contract – used by that contract and by contracts that inherit from it (referred to as ContractName.StructName from outside).
• Outside a contract (file level) – defined in a separate file and brought in with import, so several contracts can share it. The course projects use this style, e.g. CandidateMaster.sol defines struct Candidate, which VotePanelContract imports.

Creating Struct Values

Student memory s1 = Student("Asha", 101, 92);                    // 1. positional
Student memory s2 = Student({name: "Ravi", roll: 102, marks: 85}); // 2. named fields
Student memory s3;                                                 // 3. empty, then set
s3.name = "Meera"; s3.roll = 103; s3.marks = 78;

storage reference vs memory copy

• Student storage s = students[i]; – a reference; changing s.marks updates the blockchain.
• Student memory s = students[i]; – a copy; changes are lost after the function ends.
• delete students[i]; resets every member to its default value.

Example : Structs with Array and Mapping

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

struct Student {               // file-level struct (can be imported by other files)
    string name;
    uint roll;
    uint marks;
}

contract StudentRegistry {
    Student[] public students;                   // struct inside an array
    mapping(uint => Student) public byRoll;      // struct as a mapping value

    function addStudent(string calldata name, uint roll, uint marks) external {
        Student memory s = Student({name: name, roll: roll, marks: marks});
        students.push(s);
        byRoll[roll] = s;
    }

    function updateMarks(uint index, uint newMarks) external {
        Student storage s = students[index];     // reference to stored data
        s.marks = newMarks;                      // updates the blockchain
        byRoll[s.roll].marks = newMarks;
    }

    function tryUpdateCopy(uint index, uint newMarks) external view returns (uint) {
        Student memory s = students[index];      // copy only
        s.marks = newMarks;                      // NOT saved
        return s.marks;
    }

    function getStudent(uint roll) external view returns (Student memory) {
        return byRoll[roll];                     // structs can be returned
    }

    function count() external view returns (uint) {
        return students.length;
    }
}

Key Takeaways

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

Video : Structs in Solidity

Resource Files

• Chapter 13 : Solidity File
• Chapter 13 : Solidity File (Struct and Array)
• Chapter 13 : Solidity File (Struct and Mapping)

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.). Layout of a Solidity Source File (SPDX, pragmas, imports, comments). Solidity Documentation. https://docs.soliditylang.org/en/latest/layout-of-source-files.html
3. Solidity Team. (n.d.). Cheatsheet. Solidity Documentation. https://docs.soliditylang.org/en/latest/cheatsheet.html
4. 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.