Main entry point and @main attribute in Swift

Introduction

The main entry point tells the program where to start running. The @main attribute marks the starting place in Swift.

When you want to define where your Swift program begins.

When creating a command-line tool or app without using storyboard.

When you want to customize the program's startup behavior.

When you want to use a custom type as the program's entry point.

Syntax

Swift

@main
struct MyApp {
    static func main() {
        // code to run first
    }
}

The @main attribute marks the type that provides the program's entry point.

The type must have a static main() method where the program starts.

Examples

This example prints a greeting when the program starts.

Swift

@main
struct HelloWorld {
    static func main() {
        print("Hello, world!")
    }
}

You can use a class instead of a struct with @main.

Swift

@main
class AppEntry {
    static func main() {
        print("Starting app...")
    }
}

An enum can also be the entry point with @main.

Swift

@main
enum Program {
    static func main() {
        print("Program started")
    }
}

Sample Program

This program starts by printing a welcome message using the @main attribute.

Swift

@main
struct SimpleApp {
    static func main() {
        print("Welcome to SimpleApp!")
    }
}

Important Notes

Only one type in your program can have the @main attribute.

The main() method must be static and have no parameters.

If you don't use @main, Swift looks for a top-level main.swift file or uses the default app lifecycle.

Summary

The @main attribute marks the program's starting point.

The type with @main must have a static main() method.

This lets you control what runs first in your Swift program.

Practice

1. What does the @main attribute do in a Swift program?

easy

A. It marks the program's starting point where execution begins.

B. It defines a class as a data model.

C. It imports external libraries into the program.

D. It declares a variable as constant.

Solution

1. Step 1: Understand the role of @main

   The @main attribute tells Swift which type contains the program's entry point.

2. Step 2: Identify the program start

   This attribute marks where the program starts running, so it controls the first code executed.

3. Final Answer:

   It marks the program's starting point where execution begins. -> Option A

4. Quick Check:

   @main marks start point [OK]

Hint: Remember: @main means 'start here' in Swift programs [OK]

Common Mistakes:

• Confusing @main with import statements
• Thinking @main defines variables
• Assuming @main is for classes only

2. Which of the following is the correct way to declare the main entry point using @main in Swift?

easy

A. @main struct App { static func main() { print("Hello") } }

B. struct App { @main func main() { print("Hello") } }

C. @main func main() { print("Hello") }

D. func main() { @main print("Hello") }

Solution

1. Step 1: Check the placement of @main

   The @main attribute must be placed before a type (struct, class, or enum), not before a function.

2. Step 2: Verify the static main() method

   The type marked with @main must have a static main() method as the entry point.

3. Final Answer:

   @main struct App { static func main() { print("Hello") } } -> Option A

4. Quick Check:

   @main before type + static main() [OK]

Hint: Put @main before a type, not a function [OK]

Common Mistakes:

• Placing @main before a function instead of a type
• Missing static keyword on main()
• Using @main inside a function body

3. What will be the output of this Swift program?

@main struct MyApp {
    static func main() {
        print("Start")
        run()
    }
    static func run() {
        print("Running")
    }
}

medium

A. No output, program error

B. Running\nStart

C. Start

D. Start\nRunning

Solution

1. Step 1: Identify the program start

   The @main attribute marks MyApp as the entry point, so main() runs first.

2. Step 2: Trace the function calls

   main() prints "Start" then calls run(), which prints "Running".

3. Final Answer:

   Start Running -> Option D

4. Quick Check:

   main() prints Start then run() prints Running [OK]

Hint: Follow the call order inside static main() [OK]

Common Mistakes:

• Assuming run() runs before main()
• Forgetting to call run() inside main()
• Thinking @main runs run() automatically

4. Identify the error in this Swift program using @main:

@main class App {
    func main() {
        print("Hello")
    }
}

medium

A. The @main attribute cannot be used on a class.

B. The main() method must be static.

C. The print statement is invalid inside main().

D. The class must be a struct instead.

Solution

1. Step 1: Check the main() method signature

   The @main type must have a static main() method to serve as the entry point.

2. Step 2: Identify the missing static keyword

   Here, main() is an instance method, missing static, causing a compile error.

3. Final Answer:

   The main() method must be static. -> Option B

4. Quick Check:

   main() must be static in @main type [OK]

Hint: Static main() is required inside @main type [OK]

Common Mistakes:

• Omitting static keyword on main()
• Thinking @main can't be on classes
• Confusing instance and static methods

5. You want to create a Swift program that prints "Welcome!" only if a condition is true at startup. Using @main, which is the best way to implement this?

hard

A. struct App {
static func main() {
if true {
print("Welcome!")
}
}
}

B. @main struct App {
func main() {
if true {
print("Welcome!")
}
}
}

C. @main struct App {
static func main() {
if true {
print("Welcome!")
}
}
}

D. @main func main() {
if true {
print("Welcome!")
}
}

Solution

1. Step 1: Use @main on a type with static main()

   The program must have a type marked with @main and a static main() method to run at startup.

2. Step 2: Implement conditional print inside static main()

   Inside main(), use the if statement to print "Welcome!" only if the condition is true.

3. Final Answer:

   @main struct App { static func main() { if true { print("Welcome!") } } } -> Option C

4. Quick Check:

   @main type + static main() + condition inside main() [OK]

Hint: Always put @main on type with static main() method [OK]

Common Mistakes:

• Making main() an instance method
• Forgetting @main attribute on the type
• Trying to put @main on a function