Constructor function in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Constructor function

Contract Deployment

↓

Constructor Called Once

↓

Initialize State Variables

↓

Contract Ready for Use

When a contract is deployed, the constructor function runs once to set up initial values before the contract can be used.

Execution Sample

Blockchain / Solidity

contract Simple {
  uint public x;
  constructor(uint _x) {
    x = _x;
  }
}

This contract sets the variable x to the value given when the contract is created.

Execution Table

Step	Action	Input	State Change	Output
1	Deploy contract	_x = 10	x is uninitialized	No output
2	Constructor runs	_x = 10	x set to 10	No output
3	Contract ready	-	x = 10	No output

💡 Constructor runs once during deployment, then contract is ready with x = 10

Variable Tracker

Variable	Start	After Step 2	Final
x	uninitialized	10	10

Key Moments - 2 Insights

Why does the constructor run only once?

The constructor runs only during contract deployment to set initial values. After that, it does not run again, as shown in execution_table step 2.

What happens if you try to call the constructor after deployment?

You cannot call the constructor again after deployment. It is a special function that runs only once, so no state change happens after step 2.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of x after step 2?

A 10

B 0

C uninitialized

D undefined

💡 Hint

Check the 'State Change' column in step 2 where x is set to 10.

At which step does the constructor function run?

A Step 1

B Step 2

C Step 3

D Never

💡 Hint

Look at the 'Action' column to see when the constructor runs.

If the input _x was 20 instead of 10, what would be the final value of x?

A 10

B 0

C 20

D uninitialized

💡 Hint

The constructor sets x to the input value, see variable_tracker for how x changes.

Concept Snapshot

Constructor function:
- Runs once when contract is deployed
- Initializes state variables
- Cannot be called again
- Sets starting values for contract
- Example: constructor(uint _x) { x = _x; }

Full Transcript

A constructor function in blockchain smart contracts runs only once during deployment. It sets initial values for variables so the contract starts with the right data. For example, if a contract has a variable x, the constructor can set x to a value given when deploying. After deployment, the constructor cannot be called again. This ensures the contract's starting state is fixed. The execution table shows deployment, constructor running, and contract ready with x set. The variable tracker shows how x changes from uninitialized to the input value. This helps beginners see the constructor's role clearly.

Practice

1.

What is the main purpose of a constructor function in a blockchain smart contract?

easy

A. To execute code every time a function is called

B. To destroy the contract and remove it from the blockchain

C. To set initial values when the contract is deployed

D. To transfer tokens between users

Solution

1. Step 1: Understand the role of constructor

   A constructor runs only once when the contract is deployed to set initial values.

2. Step 2: Compare with other functions

   Other functions run multiple times; constructor is special for initialization only.

3. Final Answer:

   To set initial values when the contract is deployed -> Option C

4. Quick Check:

   Constructor sets initial values = B [OK]

Hint: Constructor runs once at deployment to set starting values [OK]

Common Mistakes:

• Thinking constructor runs on every function call
• Confusing constructor with regular functions
• Believing constructor can be called multiple times

2.

Which of the following is the correct syntax to declare a constructor in Solidity?

contract MyContract {
    ? {
        // initialization code
    }
}

easy

A. function constructor() public

B. constructor() public

C. def constructor()

D. init() public

Solution

1. Step 1: Recall Solidity constructor syntax

   In Solidity, the constructor is declared with the keyword constructor() without the function keyword.

2. Step 2: Check options for correct syntax

   constructor() public matches the correct syntax: constructor() public. function constructor() public wrongly uses function constructor(), which is outdated. def constructor() uses Python syntax. init() public uses a wrong name.

3. Final Answer:

   constructor() public -> Option B

4. Quick Check:

   Solidity constructor uses 'constructor()' keyword = C [OK]

Hint: Use 'constructor()' keyword without 'function' in Solidity [OK]

Common Mistakes:

• Using 'function constructor()' which is deprecated
• Using other function names like 'init()'
• Mixing syntax from other languages

3.

What will be the output of the following Solidity contract after deployment?

contract Simple {
    uint public value;
    constructor(uint _value) {
        value = _value;
    }
}

Assuming the contract is deployed with _value = 42, what is the value of value?

medium

A. 42

B. Compilation error

C. Undefined

D. 0

Solution

1. Step 1: Understand constructor parameter usage

   The constructor takes _value and assigns it to the state variable value.

2. Step 2: Check deployment argument effect

   Since the contract is deployed with _value = 42, value will be set to 42.

3. Final Answer:

   42 -> Option A

4. Quick Check:

   Constructor sets value to 42 at deployment = D [OK]

Hint: Constructor sets state variables from deployment arguments [OK]

Common Mistakes:

• Assuming default zero value instead of passed value
• Thinking constructor runs after deployment
• Confusing variable names

4.

Identify the error in this Solidity contract constructor:

contract Test {
    uint public x;
    constructor() {
        x = 10
    }
}

medium

A. Constructor cannot assign values to variables

B. Constructor name should be Test

C. State variable x is not declared correctly

D. Missing semicolon after x = 10

Solution

1. Step 1: Check Solidity syntax rules

   Each statement must end with a semicolon ;. The line x = 10 is missing a semicolon.

2. Step 2: Verify constructor naming

   Since Solidity 0.4.22+, constructors use the constructor() keyword, so naming is correct.

3. Final Answer:

   Missing semicolon after x = 10 -> Option D

4. Quick Check:

   Statements need semicolons in Solidity = A [OK]

Hint: Always end Solidity statements with semicolon [OK]

Common Mistakes:

• Using old constructor naming style
• Forgetting semicolons
• Thinking constructor can't assign variables

5.

You want to create a smart contract that stores an owner address set only once during deployment and cannot be changed later. Which constructor code snippet correctly achieves this?

contract OwnerContract {
    address public owner;
    ?
}

hard

A. constructor() { owner = msg.sender; }

B. function OwnerContract(address _owner) { owner = _owner; }

C. constructor(address _owner) { owner = _owner; }

D. constructor() { owner = address(0); }

Solution

1. Step 1: Understand owner initialization best practice

   Setting owner = msg.sender in the constructor assigns the deployer's address as owner once.

2. Step 2: Evaluate options

   constructor(address _owner) { owner = _owner; } requires passing owner address manually, which is possible but less secure. function OwnerContract(address _owner) { owner = _owner; } uses old constructor syntax. constructor() { owner = address(0); } sets owner to zero address, which is invalid. constructor() { owner = msg.sender; } correctly sets owner to deployer address.

3. Final Answer:

   constructor() { owner = msg.sender; } -> Option A

4. Quick Check:

   Use msg.sender in constructor to set owner = A [OK]

Hint: Use msg.sender in constructor to set owner securely [OK]

Common Mistakes:

• Using old constructor syntax
• Setting owner to zero address
• Passing owner address manually risking errors