iOS 5주차 수업 내용 및 수업 후 과제

2025. 9. 30. 17:48ㆍiOS 기초/수업 내용 및 수업 후 과제

반응형

🔹 전체 구조 설명

AppDelegate는 iOS 앱에서 앱의 상태 변화(실행, 종료, 백그라운드 등) 를 처리하는 역할을 합니다. 앱이 실행되거나 종료될 때 시스템이 이 클래스의 메서드들을 호출합니다.

🔸 1. 기본 선언부

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
  • import UIKit
    UIKit 프레임워크를 불러옵니다. iOS 앱의 UI 구성 요소를 담당하는 핵심 프레임워크입니다.
  • @main
    Swift 5.3부터 도입된 애트리뷰트로, 이 클래스가 앱 실행의 시작점이라는 것을 의미합니다.
  • AppDelegate: UIResponder, UIApplicationDelegate
    AppDelegate는 UIResponder를 상속하고, UIApplicationDelegate 프로토콜을 따릅니다. 이 덕분에 앱의 주요 이벤트를 처리할 수 있습니다.

🔸 2. 앱이 처음 실행될 때

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // Override point for customization after application launch.
    return true
}
  • 앱이 시작되었을 때 호출되는 메서드입니다.
  • 일반적으로 앱 설정, 초기화 작업, Firebase 초기화, 알림 권한 요청 등도 여기서 수행합니다.
  • return true는 앱이 정상적으로 실행되었음을 의미합니다.

🔸 3. 씬(Scene) 구성 (멀티 윈도우 환경 지원)

📌 iOS 13 이상부터는 멀티 윈도우(씬) 구조를 지원하기 때문에 SceneDelegate와 관련된 설정도 추가됩니다.

씬이 새로 생성될 때 호출

func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
    return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
}
  • 새 Scene이 필요할 때 호출됩니다.
  • 보통은 SceneDelegate.swift를 연결시키는 설정이 여기서 이뤄집니다.
  • "Default Configuration"은 Info.plist에 정의된 기본 설정을 사용하겠다는 의미입니다.

씬이 제거(닫힘)될 때 호출

func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
    // 해당 씬에 대한 리소스를 해제할 수 있는 곳입니다.
}
  • 사용자가 씬을 닫거나 시스템이 메모리 확보를 위해 제거할 경우 호출됩니다.
  • 여기에서 해당 씬과 관련된 리소스를 정리하면 됩니다.

📝 정리 요약

메서드 설명

didFinishLaunchingWithOptions 앱이 처음 실행될 때 호출됨
configurationForConnecting 새로운 씬이 생성될 때 어떤 설정을 사용할지 결정
didDiscardSceneSessions 사용자가 씬을 제거했을 때 호출됨

필요하다면 이 AppDelegate에 알림, Firebase, CoreData, 로그인 상태 관리 등 다양한 기능을 추가로 구현할 수 있습니다.

 

 

 

아래 SceneDelegate.swift 파일은 iOS 앱에서 "멀티 윈도우(멀티 씬)" 환경을 관리하기 위한 코드입니다.

iOS 13부터는 앱이 여러 개의 UI 창(Scene)을 가질 수 있도록 구조가 바뀌었고, 이에 따라 SceneDelegate가 도입되었습니다.

🔹 SceneDelegate 클래스의 역할

  • 각 씬(Scene) 은 하나의 사용자 인터페이스 인스턴스를 의미합니다.
  • SceneDelegate는 각 씬의 수명 주기를 관리합니다. (AppDelegate는 전체 앱의 수명 주기를 담당)

🔸 클래스 선언 및 속성

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?
  • SceneDelegate는 UIWindowSceneDelegate 프로토콜을 따르며, 이벤트를 받아 처리합니다.
  • window는 현재 씬이 사용할 창(Window)를 나타냅니다. 이 창에 ViewController가 올라갑니다.

🔸 주요 메서드 설명

✅ 1. scene(_:willConnectTo:options:)

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
    guard let _ = (scene as? UIWindowScene) else { return }
}
  • 이 메서드는 새로운 씬이 생성될 때 최초 한 번 호출됩니다.
  • 보통 이곳에서 window를 초기화하고, RootViewController를 설정합니다.
  • Storyboard를 사용하는 경우 자동으로 연결되기 때문에 별도 작업은 필요 없습니다.
  • SwiftUI 또는 코드 기반 UI라면 여기서 직접 window를 생성해야 합니다.

예시 (코드 기반 UI):

if let windowScene = scene as? UIWindowScene {
    let window = UIWindow(windowScene: windowScene)
    window.rootViewController = MyViewController()
    self.window = window
    window.makeKeyAndVisible()
}

✅ 2. sceneDidDisconnect(_:)

func sceneDidDisconnect(_ scene: UIScene) { }
  • 씬이 시스템에 의해 제거되거나 종료될 때 호출됩니다.
  • 리소스 해제, 데이터 저장 등의 작업을 수행할 수 있습니다.
  • 사용자에게 보이지 않는 시점입니다.

✅ 3. sceneDidBecomeActive(_:)

func sceneDidBecomeActive(_ scene: UIScene) { }
  • 씬이 활성화(active) 되었을 때 호출됩니다.
  • 사용자와 상호작용이 가능한 상태가 됩니다.
  • 일시 정지된 작업 재개 등을 처리할 수 있습니다.

✅ 4. sceneWillResignActive(_:)

func sceneWillResignActive(_ scene: UIScene) { }
  • 씬이 비활성화(inactive) 되기 직전에 호출됩니다.
  • 예: 전화가 오거나, 홈 화면으로 나갈 때.
  • 타이머 일시정지, 게임 일시정지 등을 처리할 수 있습니다.

✅ 5. sceneWillEnterForeground(_:)

func sceneWillEnterForeground(_ scene: UIScene) { }
  • 앱이 백그라운드 → 포그라운드 로 전환되기 직전에 호출됩니다.
  • 포그라운드에서 필요한 UI 초기화 작업 등을 수행할 수 있습니다.

✅ 6. sceneDidEnterBackground(_:)

func sceneDidEnterBackground(_ scene: UIScene) { }
  • 앱이 포그라운드 → 백그라운드 로 전환된 후 호출됩니다.
  • 데이터 저장, 네트워크 연결 종료, 상태 저장 등의 작업이 이뤄지는 곳입니다.
  • 앱이 종료될 수도 있기 때문에 여기서 중요한 작업을 저장해 두는 것이 좋습니다.

📝 요약표

메서드 이름 타이밍 주요 용도

scene(_:willConnectTo:) 씬 최초 연결 시 초기 UI 설정 (window 등)
sceneDidDisconnect 씬 종료 리소스 정리
sceneDidBecomeActive 활성화 작업 재개
sceneWillResignActive 비활성화 직전 작업 일시정지
sceneWillEnterForeground 백그라운드 → 포그라운드 직전 UI 업데이트 준비
sceneDidEnterBackground 포그라운드 → 백그라운드 이후 데이터 저장, 상태 보존

🔚 마무리

이 파일은 AppDelegate와 함께 앱의 상태 전환에 따른 다양한 로직을 처리하는 핵심입니다.
앱의 UI를 코드로 구성하려면 SceneDelegate에 많은 코드가 들어가게 되고, 스토리보드를 쓰는 경우는 상대적으로 간단하게 유지됩니다.

 

 

 

 

아래의 ViewController.swift는 iOS 앱의 기본 화면을 담당하는 UIViewController의 서브클래스입니다.
이 파일은 앱을 처음 만들 때 자동으로 생성되는 기본 템플릿입니다.

🔹 전체 코드 분석

import UIKit
  • iOS의 기본 UI 구성 요소들이 들어있는 UIKit 프레임워크를 불러옵니다.
  • UIViewController, UILabel, UIButton, UIView 등 대부분의 UI 요소들이 여기 포함되어 있습니다.
class ViewController: UIViewController {
  • ViewController는 UIKit의 기본 클래스인 UIViewController를 상속받습니다.
  • 이 클래스는 하나의 화면(View) 을 담당하며, 버튼 클릭, 데이터 표시, 네비게이션 등 UI와 관련된 대부분의 작업을 처리하는 핵심 컨트롤러입니다.
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
    }

✅ viewDidLoad()란?

  • 이 메서드는 뷰 컨트롤러의 뷰가 메모리에 로드된 직후에 호출됩니다.
  • 이 시점에서 UI 초기화 작업을 하거나 데이터를 불러오기에 적절한 타이밍입니다.
  • super.viewDidLoad()는 부모 클래스의 동작을 유지시켜 주기 위해 항상 호출해야 합니다.
  • 아래 예시처럼 이 안에 UI 구성, 이벤트 등록 등을 작성합니다.

예시: 버튼 추가

override func viewDidLoad() {
    super.viewDidLoad()
    
    view.backgroundColor = .white // 배경 흰색
    
    let button = UIButton(type: .system)
    button.setTitle("눌러보세요", for: .normal)
    button.frame = CGRect(x: 100, y: 100, width: 150, height: 50)
    button.addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
    
    view.addSubview(button)
}

@objc func buttonTapped() {
    print("버튼이 눌렸습니다!")
}

🧱 전체 클래스 구조 요약

구성 요소 설명

import UIKit UI 기능 사용을 위해 UIKit 프레임워크 임포트
class ViewController 화면 하나를 구성하는 컨트롤러 클래스
viewDidLoad() 뷰가 메모리에 올라온 뒤 실행되는 초기화 메서드

📝 추가 팁

  • 이 ViewController는 Main.storyboard와 기본적으로 연결되어 있으며, 앱이 실행되면 이 화면이 처음 보여집니다.
  • UI를 코드로 작성하거나 SwiftUI를 사용할 경우 storyboard 대신 SceneDelegate에서 이 ViewController를 수동으로 설정하기도 합니다.

 

함수 + 옵셔너리 시험에 많이 나올 가능성 높음(함수가 많이 나올 가능성이 높다)

항상 시험에 나오는 부분(녹음된 부분 확인)

첫번째 북마크 확인

일반적으로 직접만들때는 첫번째 방식을 사용하고 애플에서 나와있는 파일은 마지막 방법이 많다
두번쨰 북마크 확인

 

시험에 나오는 문제 세번째 북마크(동영상도 보기)

4?5번째 북마크 자주 나오는 문제

함수의 자료형 구하는 문제

6번째 북마크

함수의 이름

7번째 북마크

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

시험에 나옴

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { return cell }
의 자료형과 이름 알기

 

// 자료형: (UITableView, IndexPath) -> UITableViewCell
// 이름: tableView(_:cellForRowAt:)

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

print(1,2,3,separator: "-",terminator: " ")

실행결과
1-2-3

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

시험에 나오는 문제 swift print 분석

 


print 함수는 Swift에서 콘솔에 출력을 할 때 사용하는 가장 기본적인 함수입니다.
당신이 보여준 코드는 Swift 표준 라이브러리에 있는 print 함수의 함수 시그니처(정의)입니다.

print 함수 시그니처 분석

func print(
    _ items: Any...,
    separator: String = " ",
    terminator: String = "\n"
)

1. 함수 이름과 매개변수

  • print
    함수 이름입니다. 출력할 내용을 콘솔에 보여줍니다.
  • _ items: Any...
    • _ 는 함수 호출 시 첫 번째 인자에 레이블(label)을 생략할 수 있다는 뜻입니다.
    • items는 가변 인자(variadic parameter)로, 타입이 Any입니다.
      즉, print 함수는 개수에 상관없이 어떤 타입이든 여러 개의 값을 받아서 출력할 수 있습니다.
      예: print(1, "Hello", 3.14, true)
  • separator: String = " "
    • 기본값이 " " (공백)인 separator 매개변수는 여러 개의 items를 출력할 때 각 값 사이에 넣을 문자열을 지정합니다.
      예: print("A", "B", "C", separator: "-") → A-B-C
  • terminator: String = "\n"
    • 기본값이 줄바꿈 문자 "\n"인 terminator 매개변수는 출력 마지막에 붙는 문자열입니다.
      기본적으로 출력 후 줄을 바꾸지만, 다른 값으로 바꿀 수 있습니다.
      예: print("Hello", terminator: "!!") → Hello!! (줄 바꿈 없음)

2. 예시 코드

print("Hello", "World")  
// 출력: Hello World

print("Hello", "World", separator: "-")  
// 출력: Hello-World

print("Hello", terminator: "")  
print("World")  
// 출력: HelloWorld (줄 바꿈 없이 이어서 출력)

3. 핵심 요약

매개변수 설명 기본값

items (가변 인자) 출력할 값들, 여러 개 가능 -
separator 여러 값 사이에 들어갈 구분자 문자열 " " (공백)
terminator 출력 후 붙는 문자열, 보통 줄바꿈 "\n" (줄 바꿈)

4. 참고

  • print는 디버깅이나 로그를 남길 때 가장 많이 사용됩니다.
  • 출력되는 내용은 Xcode의 콘솔에 표시됩니다.
  • items의 타입이 Any라서, 숫자, 문자열, 객체 등 다양한 타입을 바로 출력할 수 있습니다.

위의 코드에 나올 수 있는 질문

질문: 이함수에서 ...은 뭡니까

디폴트인자에 대해+ 장단점 그 다음 북마크?

좋은 질문이에요! 하나씩 차근차근 설명할게요.

1. ... (점 3개, 가변 인자 — Variadic Parameter)

...는 가변 인자(Variadic Parameter) 를 의미해요.
즉, 함수에 0개 이상의 인자를 전달할 수 있다는 뜻입니다.

예시

func sum(numbers: Int...) -> Int {
    var total = 0
    for number in numbers {
        total += number
    }
    return total
}

sum(numbers: 1, 2, 3, 4)  // 결과: 10
sum(numbers: 5, 10)       // 결과: 15
sum(numbers: )            // 결과: 0 (인자가 없어도 호출 가능)

print 함수에서 items: Any...는

  • Any 타입의 값들을 여러 개 받아서 출력할 수 있다는 뜻이에요.
  • 예를 들어 print(1, "Hello", true)처럼 다양한 타입과 개수의 값을 넘겨줄 수 있죠.

2. 디폴트 인자(Default Parameter Value)란?

함수를 호출할 때 특정 매개변수를 생략하면 미리 정해놓은 기본값을 대신 사용하는 것입니다.

예시

func greet(name: String = "Guest") {
    print("Hello, \(name)!")
}

greet(name: "Alice")  // 출력: Hello, Alice!
greet()               // 출력: Hello, Guest! (name을 생략했으므로 기본값 사용)

print 함수에서의 디폴트 인자

separator: String = " ",
terminator: String = "\n"
  • separator가 생략되면 " " (공백)이 들어가고,
  • terminator가 생략되면 "\n" (줄바꿈)이 들어가서 기본 동작을 하게 됩니다.

요약

용어 의미

... 가변 인자, 여러 개 인자를 받음
디폴트 인자 인자를 안 넘기면 기본값을 사용

필요하면 가변 인자나 디폴트 인자에 대한 더 깊은 예제도 알려줄게요!

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

함수로부터 여러 개의 결과 반환하기

func sss(x : Int, y : Int) -> (sum : Int, sub : Int, div : Double)
{
    let sum = x+y
    let sub = x-y
    let div = Double(x)/Double(y) //같은 자료형만 연산 가능
    return (sum, sub, div)
} //2개의 정수를 입력받아 가감제 리턴
var result = sss(x:10,y:3)
print(result.sum)
print(result.sub)
print(result.div)

실행결과
13
7
3.3333333333333335

투플에 관해 2-1 북마크
함수의 여러개의 값을 리턴가능하다
간단하게 가능
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
func sss(x : Int, y : Int) -> (sum : Int, sub : Int, div : Double)
{
    let sum = x+y
    let sub = x-y
    let div = Double(x)/Double(y) //같은 자료형만 연산 가능
    return (sum, sub, div)
} //2개의 정수를 입력받아 가감제 리턴
var result = sss(x:10,y:3)
print(type(of: sss))
print(result.sum)
print(result.sub)
print(result.div)

sss의 자료형 알 수 있는 실행결과
(Int, Int) -> (sum: Int, sub: Int, div: Double)
13
7
3.3333333333333335

alt키를 누르고 클릭한 화면
자료형이 무엇인지 시험에 나오는 문제

2-2 북마크

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

import Foundation
func sss(x : Int, y : Int) -> (sum : Int, sub : Int, div : Double)
{
    let sum = x+y
    let sub = x-y
    let div = Double(x)/Double(y) //같은 자료형만 연산 가능
    return (sum, sub, div)
} //2개의 정수를 입력받아 가감제 리턴
var result = sss(x:10,y:3)
print(type(of: sss))
print(result.sum)
print(result.sub)
print(result.div)
String(format: "%.2f", <#T##arguments: CVarArg...##CVarArg#>)
에서

String(format: "%.2f", <#T##arguments: CVarArg...##CVarArg#>)를 사용하려면
import Foundation를 상단에 써야한다
프레임워크를 포함시킬때는 import를 상단에 써야한다
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
import Foundation
func sss(x : Int, y : Int) -> (sum : Int, sub : Int, div : Double)
{
    let sum = x+y
    let sub = x-y
    let div = Double(x)/Double(y) //같은 자료형만 연산 가능
    return (sum, sub, div)
} //2개의 정수를 입력받아 가감제 리턴
var result = sss(x:10,y:3)
print(type(of: sss))
print(result.sum)
print(result.sub)
print(result.div)
print(String(format: "%.2f", result.div))

실행결과
(Int, Int) -> (sum: Int, sub: Int, div: Double)
13
7
3.3333333333333335
3.33

2번째 캡쳐는 다른 방법으로 출력시키는것

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

...에 대해 설명 2-3 북마크

...을 쓰면 앞에는 4개의 함수를 쓰지만 뒤에 함수는 2개만써도 가능해진다

func displayStrings(strings: String...)
{
    for string in strings {
        print(string)
    }
}
displayStrings(strings: "일", "이", "삼", "사")
displayStrings(strings: "one", "two")

실행결과
일
이
삼
사
one
two

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

가변매개변수

func add(numbers: Int...) {
    var sum: Int = 0
    for num in numbers {
        sum += num
    }
    print(sum)
}

add(numbers: 1, 2, 3)


실행결과
6
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
func add(numbers: Int...) {
    var sum: Int = 0
    for num in numbers {
        sum += num
    }
    print(sum)
}

add(numbers:2,2,2,2,2) 

실행결과
10
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
func add(numbers: Int...) {
    var sum: Int = 0
    for num in numbers {
        sum += num
    }
    print(sum)
}

add(numbers:1,1,1,1,1,1,1,1,1,1)

실행결과
10
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
func add(numbers: Int...) {
    var sum: Int = 0
    for num in numbers {
        sum += num
    }
    print(sum)
}

add(numbers:1,1,1,1) 

실행결과
4

임의 개수의 정수 값을 받아서 합을 출력하는 add 함수를 Swift로 여러 가지 방식으로 작성하고,

각 방식의 실행 결과를 함께 정리해드리겠습니다.

✅ 방법 1: 가변 인자(Variadic Parameter) 사용하기

func add(numbers: Int...) {
    let sum = numbers.reduce(0, +)
    print("합계: \(sum)")
}

add(numbers: 1, 2, 3, 4)  // 합계: 10
add(numbers: 5, 10)       // 합계: 15
add(numbers: )            // 합계: 0
  • Int...는 가변 인자로, 여러 개의 Int 값을 받을 수 있습니다.
  • reduce(0, +)는 배열의 모든 값을 더하는 함수입니다.

✅ 방법 2: 배열(Array) 인자를 받아서 합 구하기

func add(numbers: [Int]) {
    let sum = numbers.reduce(0, +)
    print("합계: \(sum)")
}

add(numbers: [1, 2, 3])     // 합계: 6
add(numbers: [10, 20])      // 합계: 30
add(numbers: [])            // 합계: 0
  • 호출 시 배열로 전달해야 합니다.

✅ 방법 3: 재귀적으로 합 계산하기

func add(numbers: Int...) {
    func recursiveSum(_ nums: [Int]) -> Int {
        if nums.isEmpty { return 0 }
        return nums[0] + recursiveSum(Array(nums.dropFirst()))
    }
    
    let sum = recursiveSum(numbers)
    print("합계: \(sum)")
}

add(numbers: 1, 2, 3, 4)    // 합계: 10
add(numbers: 5, 10)         // 합계: 15
add(numbers: )              // 합계: 0
  • 재귀 함수를 이용해 배열 요소를 하나씩 더합니다.

✅ 방법 4: forEach와 클로저를 사용해서 합 구하기

func add(numbers: Int...) {
    var sum = 0
    numbers.forEach { sum += $0 }
    print("합계: \(sum)")
}

add(numbers: 10, 20, 30)     // 합계: 60
add(numbers: 5, 5, 5, 5)     // 합계: 20
add(numbers: )               // 합계: 0
  • forEach와 클로저를 사용하여 합을 구합니다.

✅ 방법 5: reduce를 사용하여 합 구하기

func add(numbers: Int...) {
    let sum = numbers.reduce(0, +)
    print("합계: \(sum)")
}

add(numbers: 1, 2, 3, 4)     // 합계: 10
add(numbers: 5, 10)          // 합계: 15
add(numbers: )               // 합계: 0
  • reduce 함수는 배열의 모든 값을 누적하여 하나의 결과를 반환합니다.

✅ 방법 6: reduce(into:)를 사용하여 합 구하기

func add(numbers: Int...) {
    let sum = numbers.reduce(into: 0) { $0 += $1 }
    print("합계: \(sum)")
}

add(numbers: 1, 2, 3, 4)     // 합계: 10
add(numbers: 5, 10)          // 합계: 15
add(numbers: )               // 합계: 0
  • reduce(into:)는 초기값을 변경하여 누적하는 방식입니다.

✅ 방법 7: for-in 반복문을 사용하여 합 구하기

func add(numbers: Int...) {
    var sum = 0
    for number in numbers {
        sum += number
    }
    print("합계: \(sum)")
}

add(numbers: 1, 2, 3, 4)     // 합계: 10
add(numbers: 5, 10)          // 합계: 15
add(numbers: )               // 합계: 0
  • 전통적인 for-in 반복문을 사용하여 합을 구합니다.

✅ 방법 8: while 반복문을 사용하여 합 구하기

func add(numbers: Int...) {
    var sum = 0
    var index = 0
    while index < numbers.count {
        sum += numbers[index]
        index += 1
    }
    print("합계: \(sum)")
}

add(numbers: 1, 2, 3, 4)     // 합계: 10
add(numbers: 5, 10)          // 합계: 15
add(numbers: )               // 합계: 0
  • while 반복문을 사용하여 배열의 모든 값을 더합니다.

✅ 방법 9: enumerated()와 reduce를 사용하여 합 구하기

func add(numbers: Int...) {
    let sum = numbers.enumerated().reduce(0) { $0 + $1.element }
    print("합계: \(sum)")
}

add(numbers: 1, 2, 3, 4)     // 합계: 10
add(numbers: 5, 10)          // 합계: 15
add(numbers: )               // 합계: 0
  • enumerated()로 인덱스와 값을 함께 순회하며 합을 구합니다.

✅ 방법 10: compactMap과 reduce를 사용하여 합 구하기

func add(numbers: Int...) {
    let sum = numbers.compactMap { $0 as Int? }.reduce(0, +)
    print("합계: \(sum)")
}

add(numbers: 1, 2, 3, 4)     // 합계: 10
add(numbers: 5, 10)          // 합계: 15
add(numbers: )               // 합계: 0
  • compactMap으로 nil을 제거한 후 합을 구합니다.

✅ 방법 11: map과 reduce를 사용하여 합 구하기

func add(numbers: Int...) {
    let sum = numbers.map { $0 }.reduce(0, +)
    print("합계: \(sum)")
}

add(numbers: 1, 2, 3, 4)     // 합계: 10
add(numbers: 5, 10)          // 합계: 15
add(numbers: )               // 합계: 0
  • map으로 값을 변환한 후 합을 구합니다.

✅ 방법 12: flatMap과 reduce를 사용하여 합 구하기

::contentReference[oaicite:0]{index=0}

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

2-4 북마크 swift에서 가장 어려운 부분

Swift에서 call by address : inout(파라매터)

호출할때는 엔퍼센트(&) 받을때는 swift에서는 포인터가 없어서 inout

(Swift에서 inout은 함수 매개변수에 참조로 값을 전달하여 함수 내에서 해당 값을 수정하고,

수정된 결과를 함수 외부로 반영할 수 있게 해주는 키워드입니다.)

var myValue = 10
func doubleValue (value: inout Int) -> Int {
    value += value
    return(value)
}
print(myValue)
print(doubleValue(value : &myValue)) //출력 값? 레포트
print(myValue)

실행결과
10
20
20

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

BMI 계산 결과 판정

let weight = 60.0
let height = 170.0
let bmi = weight / (height*height*0.0001) // kg/m*m
var body = ""
if bmi >= 40 {
    body = "3단계 비만"
} else if bmi >= 30 && bmi < 40 {
    body = "2단계 비만"
} else if bmi >= 25 && bmi < 30 {
    body = "1단계 비만"
} else if bmi >= 18.5 && bmi < 25 {
    body = "정상"
} else {
    body = "저체중"
}
print("BMI:\(bmi), 판정:\(body)")

실행결과
BMI:20.761245674740483, 판정:정상

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ간단하게 나오게 변경
import Foundation
let weight = 60.0
let height = 170.0
let bmi = weight / (height*height*0.0001) // kg/m*m
let shortenedBmi = String(format: "%.1f", bmi)
var body = ""
if bmi >= 40 {
body = "3단계 비만"
} else if bmi >= 30 && bmi < 40 {
body = "2단계 비만"
} else if bmi >= 25 && bmi < 30 {
body = "1단계 비만"
} else if bmi >= 18.5 && bmi < 25 {
body = "정상"
} else {
body = "저체중"
}
print("BMI:\(shortenedBmi), 판정:\(body)")

실행결과
BMI:20.8, 판정:정상
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ 바로 출력하는법
import Foundation

func calcBMI(weight: Double, height: Double) -> String {
    let bmi = weight / (height * height * 0.0001) // kg/m²
    let shortenedBmi = String(format: "%.1f", bmi)
    
    var body = ""
    if bmi >= 40 {
        body = "3단계 비만"
    } else if bmi >= 30 {
        body = "2단계 비만"
    } else if bmi >= 25 {
        body = "1단계 비만"
    } else if bmi >= 18.5 {
        body = "정상"
    } else {
        body = "저체중"
    }
    
    return "BMI: \(shortenedBmi), 판정: \(body)"
}

print(calcBMI(weight: 60.0, height: 170.0))

실행결과
BMI: 20.8, 판정: 정상

------------------------------------ 저장하고 출력하는법

import Foundation

func calcBMI(weight: Double, height: Double) -> String {
    let bmi = weight / (height * height * 0.0001) // kg/m²
    let shortenedBmi = String(format: "%.1f", bmi)
    
    var body = ""
    if bmi >= 40 {
        body = "3단계 비만"
    } else if bmi >= 30 {
        body = "2단계 비만"
    } else if bmi >= 25 {
        body = "1단계 비만"
    } else if bmi >= 18.5 {
        body = "정상"
    } else {
        body = "저체중"
    }
    
    return "BMI: \(shortenedBmi), 판정: \(body)"
}

print(calcBMI(weight: 60.0, height: 170.0))

실행결과
BMI: 20.8, 판정: 정상
if~else를 switch~case로

import Foundation
func calcBMI (weight : Double, height : Double) { //Void형
let bmi = weight / (height*height*0.0001) // kg/m*m
let shortenedBmi = String(format: "%.1f", bmi)
switch bmi {
case 0.0..<18.5:
print("BMI:\(shortenedBmi),판정:저체중")
case 18.5..<25.0 :
print("BMI:\(shortenedBmi),판정:정상")
case 25.0..<30.0 :
print("BMI:\(shortenedBmi),판정:1단계 비만")
case 30.0..<40.0 :
print("BMI:\(shortenedBmi),판정:2단계 비만")
default :
print("BMI:\(shortenedBmi),판정:3단계 비만")
}
}
calcBMI(weight:62.5, height: 172.3)

실행결과
BMI:21.1,판정:정상

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

일급 객체 : (1)함수를 변수에 저장 가능
func up(num: Int) -> Int {
    return num + 1
}
func down(num: Int) -> Int {
    return num - 1
}
let toUp = up // Swift 함수는 일급 객체로, 변수나 상수에 저장할 수 있음
print(up(num:10))
print(toUp(10)) //주의 : argument label인 (num:) 안 씀
// 함수를 변수에 할당하면 argument label(num:)을 생략해야 함
// let toDown =

toup의 자료형 ->let toUp: (Int) -> Int
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
func up(num: Int) -> Int {
    return num + 1
}
func down(num: Int) -> Int {
    return num - 1
}
let toUp = up // Swift 함수는 일급 객체로, 변수나 상수에 저장할 수 있음
print(up(num:10))
print(toUp(10)) //주의 : argument label인 (num:) 안 씀
// 함수를 변수에 할당하면 argument label(num:)을 생략해야 함
let toDown = down
print(down(num:10))
print(toDown(10))

실행결과
11
11
9
9

일급객체의 첫번째 특징인 권한!
함수를 매개변수로 사용하는 일급객체의 특징

고차 함수(higher-order function)
 함수를 매개변수로 받거나 반환하는 함수
 JavaScript, python, Swift에서 많이 사용
 upDown은 고차 함수
 함수를 매개변수로 받아 실행하는 함수
 Fun: (Int) -> Int
 매개변수로 정수를 받아 정수를 반환하는

함수(또는 클로저) 타입
 print(type(of:upDown))
 ((Int) -> Int, Int) -> ()
 upDown(Fun:toUp, value: 10)
 let result = Fun(value) 문장은
 let result = toUp(10)
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
func up(num: Int) -> Int {
    return num + 1
}
func down(num: Int) -> Int {
    return num - 1
}
let toUp = up
print(up(num:10))
print(toUp(10))
let toDown = down
func upDown(Fun: (Int) -> Int, value: Int) {
    let result = Fun(value)
    print("결과 = \(result)")
}
print((type(of: upDown)) //((Int) -> Int, Int) -> ()
upDown(Fun:toUp, value: 10) //toUp(10)
upDown(Fun:toDown, value: 10) //toDown(10)


실행결과
11
11
((Int) -> Int, Int) -> () //upDown의 자료형
결과 = 11
결과 = 9
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
func up(num: Int) -> Int {
    return num + 1
}
func down(num: Int) -> Int {
    return num - 1
}
let toUp = up
print(up(num:10))
print(toUp(10))
let toDown = down
func upDown(Fun: (Int) -> Int, value: Int) {
    let result = Fun(value)
    print("결과 = \(result)")
}
      print(type(of: upDown)) // ((Int) -> Int, Int) -> Void

      upDown(Fun: toUp, value: 10)   //toUp(10)
      upDown(Fun: toDown, value: 10) //toDown(10)
      upDown(Fun: toUp, value: 20)   //toUp(20)
// 함수안에 함수를 넣을 수 있다 고차함수 swift의 언어가 일급객체 일급시민이라 가능함


11
11
((Int) -> Int, Int) -> ()
결과 = 11
결과 = 9
결과 = 21
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

고차 함수(Higher-Order Functions)는 다른 함수를 인자로 받거나 반환하는 함수로, 함수형 프로그래밍에서 중요한 개념입니다. 다양한 프로그래밍 언어에서 고차 함수를 지원하며, 이를 통해 코드의 추상화와 재사용성을 높일 수 있습니다. 아래는 고차 함수를 많이 사용하는 주요 프로그래밍 언어들을 소개합니다.

1. Haskell

  • 특징: 순수 함수형 언어로, 모든 함수가 고차 함수로 다룰 수 있습니다.
  • 예시: 리스트의 각 요소에 함수를 적용하는 map 함수는 고차 함수의 대표적인 예입니다.
  map (*2) [1, 2, 3]  -- 결과: [2, 4, 6]

2. Scala

  • 특징: 객체 지향과 함수형 프로그래밍을 모두 지원하는 언어로, 고차 함수와 커링(Currying), 패턴 매칭 등의 기능을 제공합니다.
  • 예시: 컬렉션의 map 메서드는 고차 함수로, 각 요소에 함수를 적용할 수 있습니다.
  List(1, 2, 3).map(_ * 2)  // 결과: List(2, 4, 6)

3. F#

  • 특징: 함수형 프로그래밍을 기본으로 하는 언어로, 고차 함수와 커링, 패턴 매칭 등을 지원합니다.
  • 예시: map 함수는 고차 함수로, 리스트의 각 요소에 함수를 적용할 수 있습니다.
  List.map (fun x -> x * 2) [1; 2; 3]  // 결과: [2; 4; 6]

4. JavaScript (ES6+)

  • 특징: 함수형 프로그래밍 패러다임을 일부 지원하며, 고차 함수와 클로저를 활용할 수 있습니다.
  • 예시: 배열의 map 메서드는 고차 함수로, 각 요소에 함수를 적용할 수 있습니다.
  [1, 2, 3].map(x => x * 2);  // 결과: [2, 4, 6]

5. Python

  • 특징: 함수형 프로그래밍을 지원하며, 고차 함수와 클로저를 사용할 수 있습니다.
  • 예시: map 함수는 고차 함수로, 각 요소에 함수를 적용할 수 있습니다.
  list(map(lambda x: x * 2, [1, 2, 3]))  # 결과: [2, 4, 6]

6. Ruby

  • 특징: 함수형 프로그래밍을 지원하며, 고차 함수와 블록을 활용할 수 있습니다.
  • 예시: 배열의 map 메서드는 고차 함수로, 각 요소에 블록을 적용할 수 있습니다.
  [1, 2, 3].map { |x| x * 2 }  # 결과: [2, 4, 6]

7. OCaml

  • 특징: 함수형 프로그래밍을 지원하며, 고차 함수와 패턴 매칭 등을 제공합니다.
  • 예시: 리스트의 각 요소에 함수를 적용하는 List.map 함수는 고차 함수입니다.
  List.map (fun x -> x * 2) [1; 2; 3]  (* 결과: [2; 4; 6] *)

8. Common Lisp

  • 특징: 함수형 프로그래밍을 지원하며, 고차 함수와 클로저를 사용할 수 있습니다.
  • 예시: mapcar 함수는 고차 함수로, 각 요소에 함수를 적용할 수 있습니다.
  (mapcar #'(lambda (x) (* x 2)) '(1 2 3))  ;; 결과: (2 4 6)

9. Swift

  • 특징: 함수형 프로그래밍을 일부 지원하며, 고차 함수와 클로저를 사용할 수 있습니다.
  • 예시: 배열의 map 메서드는 고차 함수로, 각 요소에 클로저를 적용할 수 있습니다.
  [1, 2, 3].map { $0 * 2 }  // 결과: [2, 4, 6]

요약

순위 언어 특징 및 예시

1 Haskell 순수 함수형 언어, 모든 함수가 고차 함수로 다룰 수 있음. map (*2) [1, 2, 3]
2 Scala 함수형과 객체 지향 혼합 언어, List(1, 2, 3).map(_ * 2)
3 F# 함수형 프로그래밍 중심 언어, List.map (fun x -> x * 2) [1; 2; 3]
4 JavaScript 함수형 프로그래밍 지원, [1, 2, 3].map(x => x * 2)
5 Python 함수형 프로그래밍 지원, list(map(lambda x: x * 2, [1, 2, 3]))
6 Ruby 함수형

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

일급 객체 : (3)함수를 반환값로 사용

func up(num: Int) -> Int {
    return num + 1
}
func down(num: Int) -> Int {
    return num - 1
}
let toUp = up
print(up(num:10))
print(toUp(10))
let toDown = down
func upDown(Fun: (Int) -> Int, value: Int) {
    let result = Fun(value)
    print("결과 = \(result)")
}
print(type(of: upDown)) // ((Int) -> Int, Int) -> Void

upDown(Fun: toUp, value: 10)   //toUp(10)
upDown(Fun: toDown, value: 10) //toDown(10)
upDown(Fun: toUp, value: 20)   //toUp(20)
// 함수안에 함수를 넣을 수 있다 고차함수 swift의 언어가 일급객체 일급시민이라 가능함

//일급 객체 : (3)함수를 반환값로 사용
func decideFun(x: Bool) -> (Int) -> Int {
    //매개변수형 리턴형이 함수형
    if x {
        return toUp
    } else {
        return toDown
    }
}
let r = decideFun(x:true) // let r = toUp
print(type(of:r)) //(Int) -> Int
print(r(10)) // toUp(10)

실행결과
11
11
((Int) -> Int, Int) -> ()
결과 = 11
결과 = 9
결과 = 21
(Int) -> Int
11

Swift의 함수는 1급 객체이다.

1급 객체(first class object) 또는 1급 시민(first class citizen) 다음 조건을 충족하는 객체를 1급 객체라고 한다.

1) 변수에 저장할 수 있다.

2) 매개변수로 전달할 수 있다.

3) 반환값으로 사용할 수 있다. upDown과 decideFun은고차함수

3-1 북마크

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

클로저(Closure)

 

클로저(Closure)는 함수형 프로그래밍에서 중요한 개념으로, 함수가 자신이 선언된 환경의 변수들을 캡처하여 사용할 수 있게 해줍니다. 이러한 특성 덕분에 클로저는 다양한 프로그래밍 언어에서 널리 사용되고 있습니다. 아래는 클로저를 많이 사용하는 주요 프로그래밍 언어들을 소개합니다.

🏆 클로저를 많이 사용하는 프로그래밍 언어 순위

1. JavaScript

  • 특징: JavaScript는 클로저를 기본적으로 지원하며, 비동기 프로그래밍, 이벤트 핸들링, 콜백 함수 등에서 광범위하게 사용됩니다.
  • 예시:
  function outer() {
    let count = 0;
    return function inner() {
      count++;
      console.log(count);
    };
  }
  const counter = outer();
  counter(); // 1
  counter(); // 2

2. Python

  • 특징: Python은 함수가 일급 객체로 취급되며, 클로저를 활용한 데코레이터 패턴이 널리 사용됩니다.
  • 예시:
  def outer(x):
      def inner(y):
          return x + y
      return inner

  add_five = outer(5)
  print(add_five(3))  # 8

3. Swift

  • 특징: Swift에서는 클로저를 사용하여 비동기 작업, 이벤트 처리, 콜백 함수 등을 구현할 수 있습니다.
  • 예시:
  func makeIncrementer(incrementAmount: Int) -> () -> Int {
      var total = 0
      let incrementer: () -> Int = {
          total += incrementAmount
          return total
      }
      return incrementer
  }

  let incrementByTwo = makeIncrementer(incrementAmount: 2)
  print(incrementByTwo()) // 2
  print(incrementByTwo()) // 4

4. Java

  • 특징: Java 8부터 람다 표현식과 함께 클로저를 지원하며, 함수형 인터페이스와 스트림 API에서 활용됩니다.
  • 예시:
  public class ClosureExample {
      public static void main(String[] args) {
          int factor = 2;
          Function<Integer, Integer> multiplier = (Integer x) -> x * factor;
          System.out.println(multiplier.apply(5)); // 10
      }
  }

5. Ruby

  • 특징: Ruby는 블록, 프로시저, 람다 등을 통해 클로저를 지원하며, Enumerable 모듈의 메서드에서 자주 사용됩니다.
  • 예시:
  def make_multiplier(factor)
    return lambda { |x| x * factor }
  end

  doubler = make_multiplier(2)
  puts doubler.call(3)  # 6

6. Scala

  • 특징: Scala는 함수형 프로그래밍 언어로, 클로저를 사용하여 고차 함수 및 함수형 스타일의 코드를 작성할 수 있습니다.
  • 예시:
  def makeIncrementer(incrementAmount: Int): () => Int = {
    var total = 0
    () => {
      total += incrementAmount
      total
    }
  }

  val incrementByTwo = makeIncrementer(2)
  println(incrementByTwo()) // 2
  println(incrementByTwo()) // 4

7. Go

  • 특징: Go는 클로저를 지원하며, 함수 내부에서 정의된 함수가 외부 변수에 접근할 수 있습니다.
  • 예시:
  package main

  import "fmt"

  func main() {
      factor := 2
      multiplier := func(x int) int {
          return x * factor
      }
      fmt.Println(multiplier(3)) // 6
  }

8. Rust

  • 특징: Rust는 클로저를 지원하며, 함수형 프로그래밍 스타일을 채택할 수 있습니다.
  • 예시:
  fn main() {
      let factor = 2;
      let multiplier = |x| x * factor;
      println!("{}", multiplier(3)); // 6
  }

9. PHP

  • 특징: PHP는 클로저를 지원하며, use 키워드를 통해 외부 변수를 캡처할 수 있습니다.
  • 예시:
  <?php
  $factor = 2;
  $multiplier = function($x) use ($factor) {
      return $x * $factor;
  };
  echo $multiplier(3); // 6
  ?>

### 10. **C#**
- **특징**: C#은 람다 표현식과 함께 클로저를 지원하며, LINQ 쿼리에서 자주 사용됩니다.
- **예시**:
  
```csharp
  using System;

  class Program
  {
      static void Main()
      {
          int factor = 2;
          Func<int, int> multiplier = x => x * factor;
          Console.WriteLine(multiplier(3)); // 6
      }
  }

📌 요약

순위 언어 주요 특징 및 활용 분야

1 JavaScript 비동기 프로그래밍, 이벤트 핸들링, 콜백 함수 등
2 Python 데코레이터 패턴, 함수형 프로그래밍
3 Swift 비동기 작업, 이벤트 처리, 콜백 함수 등
4 Java 함수형 인터페이스, 스트림 API
5 Ruby 블록, 프로시저, 람다 등을 통한 클로저 지원

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

함수를 클로저 표현식으로 변경하기

func add(x: Int, y: Int) -> Int {
    return x+y
}
print(add(x:10, y:20))

실행결과
30

변경
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
func add(x: Int, y: Int) -> Int {
    return x+y
}
print(add(x:10, y:20))
let add1 = {(x: Int, y: Int) -> Int in
    return x+y
}

실행결과
30
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
func add(x: Int, y: Int) -> Int {
    return x+y
}
print(add(x:10, y:20))
let add1 = {(x: Int, y: Int) -> Int in
    return x+y
}
print(add1(1, 2))

실행결과
30
3

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
func add(x: Int, y: Int) -> Int {
    return x + y
}
print(add(x: 10, y: 20))  // 출력: 30

let add1 = { (x: Int, y: Int) -> Int in
    return x + y
}
print(add1(1, 2))  // 출력: 3

func mul(x: Int, y: Int) -> Int {
    return x * y
}
let result1 = mul(x: 10, y: 20)
print(result1)  // 출력: 200

let multiply: (Int, Int) -> Int = { (x: Int, y: Int) in
    return x * y
}
let result2 = multiply(10, 20)
print(result2)  // 출력: 200

gpt로 추가 정리

표시된 부분이 클로저

 

후행클로저 부분은 시험범위 아님

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

클래스

{위쪽(지금까지는)은 함수형 언어 특징 / 클래스부터는 객체지향성 특징}

----------------------

struct vs class 시험범위 x

--------------------

3-2 북마크

----------------------------

(stored) property // 저장되어있는 프로퍼티

매우 중요한 오류

초기값 없이 쓰면 안된다

swift에서 초기값이 있지 않으면 에러난다

3-3 북마크

class Man {
    var age : Int = 0//age = 변수
    var weight : Double = 0.0
}
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
초기값을 주는것 말고 에러를 없애는법
옵셔널 변수는 초기값이 자동으로 1이다
2번쨰 방법은 잘 안쓰는 방법이다
class Man {
    var age : Int?//age = 변수
    var weight : Double?
}
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
3번째 방법이 제일 많이 사용하는 방법이다
swift에서 함수를 만들때는 func를 반드시 사용해야하지만
이니셜라이저를 사용할때는 앞에 func키워드를 사용하지 않는다

class Man {
    var age : Int
    var weight : Double
    init(){
        age = 1
        weight = 3.5
    }
}
아래 gpt설명

 

1. 디폴트 값 제공하기

프로퍼티에 기본값을 할당하여 인스턴스화 시 자동으로 초기화되도록 합니다.

class Man {
    var age: Int = 0
    var weight: Double = 0.0
}

이렇게 하면 Man()으로 인스턴스를 생성할 수 있습니다.

2. 옵셔널 프로퍼티 사용하기

프로퍼티를 옵셔널로 선언하여 초기값 없이도 인스턴스를 생성할 수 있도록 합니다.

class Man {
    var age: Int?
    var weight: Double?
}

이렇게 하면 Man()으로 인스턴스를 생성할 수 있으며, 나중에 프로퍼티에 값을 할당할 수 있습니다.

3. 이니셜라이저 추가하기

사용자가 직접 값을 전달하여 초기화할 수 있도록 생성자를 정의합니다.

class Man {
    var age: Int
    var weight: Double

    init(age: Int, weight: Double) {
        self.age = age
        self.weight = weight
    }
}

이렇게 하면 Man(age: 30, weight: 70.5)와 같이 인스턴스를 생성할 수 있습니다.

필요한 상황에 맞게 이 세 가지 방법 중 하나를 선택해 사용하시면 됩니다!

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

메서드 정의

3-4 북마크

class Man {
    var age : Int = 1
    var weight : Double = 3.5
//    init(){
//        age = 1
//        weight = 3.5
//    } // 간단하게 하기 위해 초기값을 넣음
    func display(){ //인스턴스 메서드
        print("나이=\(age), 몸무게=\(weight)")
    }
}
var x : Int = 10
var kim : Man = Man()
print(kim.age)

실행결과
1

Man() ()를 쓰는이유 함수를 호출하기 위해 씀 .init이 생략되어 있음 아래가 생략 안하고 쓴 코드
북마크 3-5,3-6
-----------------------
class Man {
    var age : Int = 1
    var weight : Double = 3.5
    init(){}
    func display(){ //인스턴스 메서드
        print("나이=\(age), 몸무게=\(weight)")
    }
}
var x : Int = 10
var kim : Man = Man.init()
print(kim.age)

실행결과
1
-------------------------
class Man {
    var age : Int = 1
    var weight : Double = 3.5
    init(){}
    func display(){ //인스턴스 메서드
        print("나이=\(age), 몸무게=\(weight)") //age와 weight는 스터워드프롬포티? 북마크3-6
    }
}
var x : Int = 10
var kim : Man = Man() //디폴트 이니셜라이저 북마크 3-7
print(kim.age)
kim.display()

실행결과
1
나이=1, 몸무게=3.5
class Man {
    var age : Int = 1
    var weight : Double = 3.5
    init(){}
    func display(){ //인스턴스 메서드
        print("나이=\(age), 몸무게=\(weight)")
    }
}
var x : Int = 10
var kim : Man = Man()
print(kim.age)
kim.display()
이 소스에서 Man()는 왜 한거야?

좋은 질문이야!

`Man()`은 **`Man` 클래스의 인스턴스(객체)를 생성**하기 위해 호출하는 거야.

---

### 자세히 설명하면:

* `Man`은 클래스 이름이고,
* `Man()`은 `Man` 클래스에 정의된 **초기화 메서드(이니셜라이저, initializer)**를 
호출해서 새로운 객체를 만드는 문법이야.

여기서는 `init(){}` 이라는 기본 생성자가 있어서 아무 인자도 없이 `Man()`을 호출하면 
`age`는 1, `weight`는 3.5로 초기화된 `Man` 객체가 만들어져.

---

### 즉,

```swift
var kim : Man = Man()
```

* `kim`이라는 변수가 `Man` 타입의 **새로운 인스턴스**를 참조하도록 만든 거고,
* `Man()`을 호출해서 객체를 생성해서 그걸 `kim`에 할당한 거야.

---

이후에 `kim.age`나 `kim.display()`를 호출해서 그 객체의 프로퍼티와 메서드를 사용할 수 있는 거지.

---

요약하면:
**`Man()` 은 `Man` 클래스의 객체를 새로 만드는 생성자 함수 호출이다!**

'iOS 기초 > 수업 내용 및 수업 후 과제' 카테고리의 다른 글

iOS 9주차 수업 내용 및 수업 후 과제  (0) 2025.10.28
iOS 6,7주차  (0) 2025.10.14
iOS 3주차 수업 내용 및 수업 후 과제  (0) 2025.09.23
iOS 4주차 수업 내용 및 수업 후 과제  (0) 2025.09.23
2주차 iOS 수업 내용 및 수업 후 과제  (0) 2025.09.09

관련글

티스토리툴바