Main entry point and @main attribute in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main entry point in a Swift program?

The main entry point is where the program starts running. In Swift, this is usually the main.swift file with top-level code or a type marked with the @main attribute.

beginner

What does the @main attribute do in Swift?

The @main attribute tells Swift which type contains the program's entry point. Swift runs the code inside that type's static func main() method first.

intermediate

How do you define a custom main entry point using @main in Swift?

You create a struct, class, or enum with the @main attribute and add a static func main() method. Swift runs this method when the program starts.

beginner

Can a Swift program have more than one @main attribute?

No, a Swift program can only have one @main attribute. It marks the single entry point for the program.

intermediate

What happens if you don’t use @main in a Swift program?

If you don’t use @main, Swift looks for a top-level main.swift file with code outside any type to start running the program.

What is the purpose of the @main attribute in Swift?

A To import a module

B To mark the program's entry point

C To declare a variable

D To define a class

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

Which method must be implemented inside a type marked with @main?

A static func start()

B func start()

C func main()

D static func main()

The type marked with @main must implement static func main() as the entry point.

Can a Swift program have multiple @main attributes?

A No, only one is allowed

B Only if they are in different modules

C Only if they are in different files

D Yes, as many as needed

Swift allows only one @main attribute to mark the single entry point.

If no @main attribute is used, how does Swift find the entry point?

A It looks for a <code>main.swift</code> file with top-level code

B It uses the first class declared

C It uses the first function declared

D It throws an error

Without @main, Swift looks for a main.swift file with top-level code to start execution.

Which of these can be marked with @main in Swift?

A Only classes

B Only structs

C Structs, classes, or enums

D Only enums

In Swift, structs, classes, or enums can be marked with @main to define the entry point.

Explain how the @main attribute works in Swift and how it defines the program's entry point.

Think about how Swift knows where to start running your code.

Describe what happens if you write a Swift program without using the @main attribute.

Consider how Swift finds the start point without @main.

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