코드는 유지보수 및 수정이 용이하도록 작성해야 하는데, MVC 아키텍쳐는 그러한 여러가지 방법들 중 하나이다.


What is MVC?

Model, View, Controller의 약자이다. 즉 하나의 프로젝트를 크게 모델, 뷰, 컨트롤러로 나누어서 작업하는 것을 의미한다. 

 

Model - what your app is

 

View - contoller's minons

 

Controller - how model is presented

 

모델에는 해당 앱이 무엇인지를, 컨트롤러는 해당 모델이 어떻게 보여지는지를 기술하는 것이다. 그렇다면 뷰는? 컨트롤러가 지시하는대로 유저에게 모습을 보여주는 부분이라고 생각하면 된다. 

전반적인 통신은 모델과 컨트롤러, 그리고 컨트롤러와 뷰 이렇게 통신을 하게된다. 즉 모델과 뷰는 직접적으로 통신을 할 수 없다는 얘기. 

 

모델은 자신에게 변경사항이 일어나면 컨트롤러에게 신호를 보낸다. 그렇게 되면 컨트롤러는 모델을 재탐색하여 변경사항을 알아내고 이를 뷰에 반영하게 된다. 해당 통신을 ios 에서는 KVO(key-value observing)이라고 한다. 

 

뷰는 사용자의 이벤트를 감지하고 이를 action을 통해 컨트롤러에게 알린다. 반대로 컨트롤러는 outlet을 통해 자신의 지시를 전달하게 된다. MVC모델은 컨트롤러(controller)가 무엇을(model) 어떻게 표현(view)할것인지 구분하여 코드를 작성하는 방법이라고 생각하면 된다.

 

 그렇다면 화면이 여러개인 앱들이 있을텐데 그러한 앱들은 MVC를 어떻게 적용하느냐? 라는 질문이 생기게 된다. 이 경우, 여러개의 MVC가 만들어 지는데 각 MVC는 나머지 MVC들을 하나의 뷰로 여기게 된다.


Demo

해당 데모는 지난번 카드뒤집기 데모에 MVC를 적용하여 카드 짝맞추기 게임으로 만든 것이다. 

Model

import Foundation

struct Card{
    //카드가 앞면인지 나타내는 속성
    var isFaceUp = false
    //카드의 짝이 맞는지 나타내는 속성
    var isMatchedUp = false
    //카드의 짝을 확인하기 위한 속성
    var identifier: Int
    
    //정적 선언. 즉 card타입 자체에 부여되는 속성이다.
    static var identifierFactory = 0
    
    //정적 선언. card타입 자체에 부여되는 함수. id를 하나씩 증가시켜 반환한다.
    static func getUniqueIdentifier() -> Int{
        identifierFactory += 1
        return identifierFactory
    }
    
    //카드의 초기화가 일어날 때 마다 고유의 id를 생성한다.
    init(){
        self.identifier = Card.getUniqueIdentifier()
    }

}

 

import Foundation

class Concentration{
    //card타입의 배열 생성
    var cards = [Card]()
    
    //유일하게 앞면 상태의 카드를 나타내는 속성 이후에 두번째로 오픈되는 카드와 id를 비교하기위해 사용된다.
    var indexOfOneAndOnlyFaceupCard:Int?
    
    //카드를 선택할 때 수행할 함수이다. 유저가 선택한 카드가 몇번째 배열인지 배개변수로 받는다.
    func chooseCard(at index: Int){
        print("card's id:",cards[index].identifier)
        print("card's index:",index)
        
        if !cards[index].isMatchedUp{
            //유저가 선택한 카드가 만약 쌍을 이루지 못한 상태라면,
            if let matchIndex = indexOfOneAndOnlyFaceupCard, matchIndex != index{
                //만약 유저가 선택한 카드 제외, 앞면인 상태의 카드가 한장이 존재한다면, 해당카드와 id를 비교
                if cards[matchIndex].identifier == cards[index].identifier{
                    //서로의 id가 같다면, 두 카드는 쌍을 이룬 상태로 전환
                    cards[matchIndex].isMatchedUp = true
                    cards[index].isMatchedUp = true
                }
                //그렇지 않다면 유저가 선택한 카드는 앞면을 향하게 한다.
                cards[index].isFaceUp = true
                //더이상 유일하게 앞면을 보고있는 카드는 없다.
                indexOfOneAndOnlyFaceupCard = nil
            } else{
                //indexOfOneAndOnlyFaceupCard값이 nil이라면, 즉 유저가 선택한 카드 이외 앞면인 카드가 한장보다 많으면,
                for flipDownIndex in cards.indices{
                    //모든 카드를 뒷면으로 바꾼다.
                    cards[flipDownIndex].isFaceUp = false
                }
                //유저가 선택한 카드는 앞면으로 바꾼다.
                cards[index].isFaceUp = true
                //유저가 선택한 카드는 앞면을 바라보는 유일한 한장이다.
                indexOfOneAndOnlyFaceupCard = index
            }
        }
    }
    
    //생성할 카드쌍의 수를 입력받는다. 즉 입력받는 수의 두배만큼 카드를 만든다.
    init(numberOfPairsOfCards:Int){
        for _ in 0..<numberOfPairsOfCards{
            //동일카드 한쌍을 배열에 추가한다.
            let card = Card()
            cards += [card,card]
        }
        
        //TODO: 카드섞기
        for index in 0..<numberOfPairsOfCards{
            let randomIndex = Int(arc4random_uniform(UInt32(numberOfPairsOfCards)))
            let swpidentifier = cards[index].identifier
            cards[index].identifier = cards[randomIndex].identifier
            cards[randomIndex].identifier = swpidentifier
        }
    }
}

View

Controller

import UIKit

class ViewController: UIViewController {
    //게임 생성. 카드 쌍의 수는 카드버튼 갯수의 절반이다.
    lazy var game = Concentration(numberOfPairsOfCards: cardButtons.count+1/2)
    
    //카드를 뒤집은 수를 나타내는 레이블.
    @IBOutlet weak var flipCountLabel: UILabel!
    
    //flipCountLabel에 표시할 변수. 당연하게도 0부터 시작한다.
    var flipCount = 0 {
        //변수의 값 변동이 일어날 때마다 수행되는 메소드. flipCountLabel에 변경된 값을 전달하고 표시한다.
        didSet{
            flipCountLabel.text = "flipCount: \(flipCount)"
        }
    }
    
    //UIButton을 카드모양으로 배치하였다. 해당 카드버튼들을 배열로 담았다.
    @IBOutlet var cardButtons : [UIButton]!
    
    //사용자가 카드를 터치할 때의 이벤트 함수. 어떤 카드가 터치된건지 UIButton을 매개변수로 넘긴다.
    @IBAction func touchCard(_ sender: UIButton) {
        if let cardNumber = cardButtons.firstIndex(of: sender){
            //sender 즉 사용자가 터치한 카드가 cards배열에서 몇번째 카드인지 넘겨준다.
            game.chooseCard(at: cardNumber)
            //뷰에 모델의 변경사항을 반영한다.
            updateViewFromModel()
        } else{
            //만약 카드가 cards배열에 없다면 오류문 출력
            print("card is not in cardsArray")
        }
    }
    
    //모델의 변경사항을 뷰에 알려준다.
    func updateViewFromModel() {
        for index in cardButtons.indices{
            //카드버튼과 카드는 배열 속 번호가 동일하다.
            let button = cardButtons[index]
            let card = game.cards[index]
            
            if card.isFaceUp{
                //앞면인 카드가 있다면, 카드에 해당하는 카드버튼에 이모지를 삽입
                button.setTitle(emoji(for: card), for: UIControl.State.normal)
                button.backgroundColor = #colorLiteral(red: 1, green: 1, blue: 1, alpha: 1)
                
                if !card.isMatchedUp{
                    //아직 짝이 없는 상태의 카드라면 flipCount증가.
                    flipCount += 1
                }
            } else{
                //카드가 뒷면인 상태라면 해당 카드버튼은 이모지를 지우고 뒷면으로 바꾼다.
                button.setTitle("", for: UIControl.State.normal)
                //카드가 만약 짝이 맞는 상태라면 투명하게 그렇지 않다면 주황색으로 바꾼다.
                button.backgroundColor = card.isMatchedUp ? #colorLiteral(red: 1, green: 1, blue: 1, alpha: 0) : #colorLiteral(red: 1, green: 0.5763723254, blue: 0, alpha: 1)
            }
        }
    }
    
    //이모티콘 후보들이다. 배열로 담아놓았다.
    var emojiChoices = ["🦇", "😱", "🙀", "👿", "🎃", "👻", "🍭", "🍬", "🍎"]
    
    //emojiChoices에서 이모지를 뽑아 [카드의 id: 이모지] 쌍으로 딕셔너리를 생성한다.
    var emoji = [Int:String]()
    
    //카드에 이모지를 그려넣는 함수. 카드를 매개변수로 받는다. 이모지를 반환한다.
    func emoji(for card: Card) -> String{
        if emoji[card.identifier] == nil, emojiChoices.count > 0{
            //만약 매개변수 카드의 id가 emoji딕셔너리의 키로 존재하지 않는다면, 이모지 후보에서 랜덤하게 뽑아온뒤 [카드id:이모지] 딕셔너리에 추가한다.
            let randomIndex = Int(arc4random_uniform(UInt32(emojiChoices.count)))
            emoji[card.identifier] = emojiChoices.remove(at: randomIndex)
        }
        
        //카드 id를 키값으로 이모지 반환
        return emoji[card.identifier] ?? "?"
    }
}

lazy var

Cannot use instance member 'cardButtons' within property initializer;

property initializers run before 'self' is available

컨트롤러를 작성하면서 새롭게 배운것은 lazy이다.  game을 생성할 때 카드쌍의 수를 입력해야 하는데, 카드의 갯수를 늘리거나 줄이는 경우에, 이에 대응하여 game이 유연하게 동작하는 게 하기 위해 cardButtons 배열의 갯수를 읽어오도록 했다. 우선 스위프트는 효율적인 메모리관리를 위해 변수의 초기화가 이루어져야만 사용을 할 수 있다. 하지만 game변수를 초기화하기 위해 속성을 초기화하려다보니 속성을 초기화하려면 변수가 초기화 되어있어야 한다고 오류가 뜨고 말았다. 이러한 꼬인 부분을 해결하기 위해 사용한 것이 lazy였다. lazy로 선언된 변수는 일단 초기화가 완료된 것으로 취급이 되고, 해당 변수가 필요하게 되면 초기화가 시작된다. 이렇게 해서 상호간에 일으키는 오류를 해결했던 점이 흥미로웠다. 

 

optional ?? unwrap

emoji(for: card) 함수를 보면 마지막에 return emoji[card.identifier] ?? "?"  부분이 있다. 이러한 표현방법을 다른곳에서도 자주 봤지만 뜻을 잘 몰랐고 이번 강의를 통해서 이해하게 되었다. 해당 코드는 본래 아래와 같은 표현이다. 

if emoji[card.identifier] != nil {
    return emoji[card.identifier]!
} esle {
    return "?"
}

emoji딕셔너리가 카드의 id로 key를 가지고 있으면 해당하는 value를 unwrap하여 반환하고, 해당 키를 가지고 있지 않으면 "?"를 반환하는 코드를 return emoji[card.identifier] ?? "?"라는 한줄로 대치한 것이다. 

 

'iOS > Stanford' 카테고리의 다른 글

day06_multiTouch  (0) 2022.03.26
day05_view  (0) 2021.12.30
day04_swift_part2  (0) 2021.10.25
day03_swift_part1  (0) 2021.10.12
day01_ios  (0) 2021.09.28

edwith를 통해 스탠포드대학의 ios강의를 번역자막을 보면서 시청할수있다. 해당 강의를 시청하며 정리한 내용을 적어보려고 한다. 


what's in ios?

ios에 대한 간략한 설명을 해보자면 초기의 os X for iphone에서 3버전에는 iphone os, 2010년 4버전이 나오면서 ios라는 이름으로 정착되었다. ios는 크게 cocoa touch, media, core service, 

core OS로 구분되어 사용자와 하드웨어간의 의사소통을 담당한다.

 

사용자

cocoa touch

media

core service

core OS

하드웨어

 

cocoa touch는 전반적인 ui를 담당한다. 버튼, 슬라이더, 맵킷, 카메라 등 사용자와 가장 가까운 부분의 처리를 수행한다.

media는 말 그대로 비디오, 오디오, 이미지 등 ios의 미디어 부분을 할당한다. 

core service는 core location, network와 같은 핵심적인 서비스를 담당한다. 

core OS는 BSD계열 unix로 구성되어있으며, 당연하게도 c언어 베이스이다. 

 

해당 강의에서는 cocoa touch와 core service에 대해 다룰 예정이다.


Demo

이번 강의에 대한 카드뒤집기 데모를 만들었다. 

import UIKit


class ViewController: UIViewController {
    //카드를 뒤집은 수를 나타내는 레이블.
    @IBOutlet weak var flipCountLabel: UILabel!
    
    //flipCountLabel에 표시할 변수. 당연하게도 0부터 시작한다.
    var flipCount = 0 {
        //변수의 값 변동이 일어날 때마다 수행되는 메소드. flipCountLabel에 변경된 값을 전달하고 표시한다.
        didSet{
            flipCountLabel.text = "flipCount: \(flipCount)"
        }
    }
    
    //카드를 뒤집는 함수. 카드에 그려질 이모티콘(문자열)과 어떤 카드에 그릴지 UIButton을 매개변수로 받는다.
    func flipCard(withEmoji emoji:String, on button:UIButton) {
        if button.currentTitle == emoji{
            //카드가 앞면일 경우. 카드의 현재 문양(currentTitle)과 배개변수로 받은 이모티콘이 같다.
            button.setTitle("", for: UIControl.State.normal)
            button.backgroundColor =  colorLiteral(red: 1, green: 0.5763723254, blue: 0, alpha: 1)
        } else{
            //카드가 뒷면일 경우. 카드에 배개변수로 받은 이모티콘을 그리고(setTitle) 배경을 흰색으로, flipCount를 증가시킨다.
            button.setTitle(emoji, for: UIControl.State.normal)
            button.backgroundColor =  colorLiteral(red: 1, green: 1, blue: 1, alpha: 1)
            //flipCount가 증가되면 didSet이 수행된다.
            flipCount += 1
        }
    }
    
    //UIButton을 카드모양으로 배치하였다. 해당 카드들을 배열로 담았다.
    @IBOutlet var cards: [UIButton]!
    
    //카드에 그려넣을 그림을 이모티콘으로 표현한다. 배열로 담았다.
    let emojis = ["🐶","🦊","🐶","🦊"]
    
    //사용자가 카드를 터치할 때의 이벤트 함수. 어떤 카드가 터치된건지 UIButton을 매개변수로 넘긴다.
    @IBAction func touchCard(_ sender: UIButton) {
        if let cardNumber = cards.firstIndex(of: sender){
            //sender 즉 사용자가 터치한 카드가 cards배열에 몇번째 배열인지 반환한다.
            //해당 카드와 같은 배열번호의 이모지를 배개변수로 넘겨 flipCard()함수 수행.
            flipCard(withEmoji: emojis[cardNumber], on: sender)
        } else{
            //만약 카드가 cards배열에 없다면 오류문 출력
            print("card is not in cardsArray")
        }
    }
}

여기서 인상깊었던 부분은 함수부분이다. 처음 스위프트를 배울 때 함수선언부분에서 왜 매개변수명을 굳이 두개나 적을까 궁금했는데, 새touchCard()flipCard() 호출부분을 보면 스위프트가 어째서 매개변수명을 두개로 적는지 알 수 있었다. 애플은 코드를 읽을 때 최대한 사람의 입장에서 자연스럽게 코드를 읽을 수 있기를 바랬고, 그러한 의도가 호출부에서 잘 나타났다.

 

flipCard(withEmoji: emojis[cardNumber], on : sender) -> 전달자에 들어있는 이모지가 그려진 카드를 뒤집어라. 

 

반대로 선언부에서는 withemojion이라는 변수명이 부자연스러우니 emojibutton이라는 변수명으로 사용이 된다. 이러한 변수명의 선택은 코드의 유지보수면에서 큰 도움이 된다고 생각한다. 강의를 많이 찾아본 것은 아니지만 적어도 학원강의에서는 이러한 부분을 전혀 알려주지 않았던 것을 보면 확실히 본토 대학강의가 훨씬 더 영양가있다고 생각한다.

 

이번에 didSet{ }에 대해서도 처음 배웠다. 속성감시자라고 번역이 되어있는데, 우리가 알고있는 변수는 스위프트에서 속성이라 부른다고 한다. 속성(변수)값이 변경될 경우 항상 수행되는 작업을 명시해줄 수 있다. 해당 데모에서 flipCount를 증가할 때 마다 레이블 수정작업을 따로 적을 필요없이 didSet{ }에 레이블 수정작업을 적어주어 코드라인을 줄일 수 있게 되었다.

 

 

'iOS > Stanford' 카테고리의 다른 글

day06_multiTouch  (0) 2022.03.26
day05_view  (0) 2021.12.30
day04_swift_part2  (0) 2021.10.25
day03_swift_part1  (0) 2021.10.12
day02_MVC  (0) 2021.10.03

https://github.com/scenee/FloatingPanel#change-the-backdrop-alpha

 

GitHub - scenee/FloatingPanel: A clean and easy-to-use floating panel UI component for iOS

A clean and easy-to-use floating panel UI component for iOS - GitHub - scenee/FloatingPanel: A clean and easy-to-use floating panel UI component for iOS

github.com

현재 FloatingPanel을 이용하여 개발 중 만났던 삽질에 대해 글을 써본다. 

우선 FlotingPanel에 대해 간략하게 설명하자면 애플지도, 애플주식 앱을 켜면 나오는 하단의 bottomSheet이다.

이러한 기본 뷰 위에 또 다른 뷰를 띄우는데 쉽게 제작할 수 있게 라이브러리로 깃허브에 올라와있다. 관심있다면 해당링크로 들어가보자. 

FloatingPanel 라이브러리를 사용중 레이아웃을 수정하여 초기에 뜨는 뷰의 높이를 수정하려는데 아무리 수정해도 반영이 되질 않았다. 

class ViewController: UIViewController, CLLocationManagerDelegate, MKMapViewDelegate, FloatingPanelControllerDelegate{

    @IBOutlet var mapView: MKMapView!
    
    var fpc: FloatingPanelController!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        urlrequest(count: 1)
        
        mapView.delegate = self
        
        fpc = FloatingPanelController(delegate: self)
        
        let contentVC = UIStoryboard(name: "Main", bundle: nil).instantiateViewController(identifier: "ContentVC")
        fpc.set(contentViewController: contentVC)
        
        fpc.addPanel(toParent: self)

        floatingPaneldesign()
        
        fpc.show()
        fpc.layout = CustomFloatingPanelLayout()
    }

class CustomFloatingPanelLayout: FloatingPanelLayout{
    var position: FloatingPanelPosition = .bottom
    var initialState: FloatingPanelState = .tip
    
    var anchors: [FloatingPanelState: FloatingPanelLayoutAnchoring] {
            return [
                .full: FloatingPanelLayoutAnchor(fractionalInset: 0.5, edge: .bottom, referenceGuide: .superview),
                .half: FloatingPanelLayoutAnchor(absoluteInset: 270.0, edge: .bottom, referenceGuide: .superview),
                .tip: FloatingPanelLayoutAnchor(absoluteInset: 110.0, edge: .bottom, referenceGuide: .superview)
            ]
        }
}

문제의 코드. CustomFloatingPanelLayout에서 initialState 변수가 첫 화면이 나올때의 높이를 조절하는 부분인데 아무리 바꾸어도 적용이 되지 않았다. 며칠동안 initialState변수만 들여다 보고있었는데 결론은 메인 뷰 컨트롤러에 있는 fpc.show()부분이었다. quick help를 읽어보니 다음과 같이 적혀있었다. 

Summary
Shows the surface view at the initial position defined by the current layout

"현재 레이아웃으로 정의된 포지션에 뷰를 띄운다." 나는 여태 라이브러리 기본값의 위치로 뷰를 띄우고 나서 레이아웃을 바꾸었으니 첫 화면이 뜰때는 무조건 기본좌표로만 띄워졌던 것이다. 문제를 인지하고나서 fpc.show()fpc.layout = Custom... 두 줄의 위치를 바꾸어주니 내가 원하던데로 첫 화면부터 원하는 높이로 띄울 수 있게 되었다. 

앱 제작 도중 만난 에러다.

여기에 막혀서 며칠이나 해맸다.. 늘 그렇듯 정말 사소한 실수였고, 모르면 그만큼 고생하게 된다는 걸 느꼈다. 

 

func mapView(_ mapView: MKMapView, didSelect view: MKAnnotationView){
        if let eventAnnotation = view.annotation as? EventAnnotation{
            print("\(eventAnnotation.title)핀이 눌렸습니다.")
            if let contentVC = storyboard?.instantiateViewController(identifier: "SearchVC") as? SearchVC{
                contentVC.updateView(eventAnnotation.title!, "", "")
            }
        }
    }

메인 컨트롤러에 있는 맵뷰의 핀을 누르면 이벤트 처리를 통해 FloatingPanel(SearchVC를 할당하였다.)에 띄워져 있는 뷰에 접근하려하였다.

func updateView(_ text1:String, _ text2:String, _ text3:String) {
        self.APGroupName.text = text1
        self.addressDong.text = text2
        self.addressDetail.text = text3
    }

이벤트 발생 시 SearchVC 클래스의 IBOutlet label의 텍스트를 수정하려는 부분에서 해당 에러가 발생했다.

에러의 원인은 검색을 통해서 금방 찾을 수 있었는데 원인은 바로 할당되지 않은 변수(nil)에 값을 넣으려니 에러가 발생한 것.. 

여기서 눈치를 챘어야했는데 바보같이 updateView()부분만 계속해서 수정했었다.

 

열심히 삽질을 하다가 문득 FloatingPanel쪽을 들여다 보게되었고, 여기서 해법을 찾았다.

나는 FloatingPanel에 띄워져 있는 뷰 컨트롤러에 접근을 해야했는데, 스토리보드의 instantiateViewController()를 통해 접근하려 했으니, 존재하지 않는 뷰에 접근하려 해서 에러가 발생했던 것이다. 

클래스의 특성에는 initializer(생성자), self, inheritance(상속)가 있다. 

init( )

클래스는 객체생성 시 자동으로 단 한번만 생성자 메소드를 호출한다. 스위프트에서는 init()이라는 이름으로 사용한다. 

주로 클래스 멤버변수 초기화의 용도로 사용을 한다.

class AAA{
    var a = 10
    var b = "아기상어"
    
    init(aa:Int, bb:String){s
        //생성자 --> 멤버변수 초기화로 주로 사용한다.
        print("AAA initializer start: \(aa), \(bb)")
        a = aa
        b = bb
    }
    
    func fn_1(){
        print("AAA fn_1() start: \(a), \(b)")
    }
    
    func fn_2(){
        print("AAA fn_2() start: ")
    }
}
var cc1 = AAA(aa:1234, bb:"엄마상어")
var cc2 = AAA(aa:456, bb: "할아버지상어")
cc1.fn_1()
cc2.fn_1()

init()은 따로 호출하지 않아도 알아서 실행이 되는 모습을 볼 수 있다. 예시와 같이 생성자를 통해 객체 생성과 동시에 변수의 초기화가 이루어지니 더 간결하게 코드를 적을 수 있다.

var arr = [AAA(aa:10, bb:"정우성"),
           AAA(aa:20, bb:"정좌성"),
           AAA(aa:60, bb:"정남성"),
           AAA(aa:80, bb:"정중성")]

for qq in arr{
    qq.fn_1()   //배열로 담아 메소드 실행
}

배열을 이용하여 메소드를 실행할 수 있다는 점도 알아두자.


self

self는 멤버요소 접근자로서 자기 자신 클래스 내 멤버변수에 접근할 때 사용된다.

class AAA{
    var a:Int!      
    var b:String!   
    
    init(_ a:Int, _ b:String){
        self.a = a  //self -> 현재 인스턴스의 멤버요소 접근자.
        self.b = b  //매개변수와 멤버변수의 혼동을 막기위해 명시적으로 선언하기 위한 용도로도 쓰인다.
        
        ppp()
    }
    
    func ppp(){
        print("a:\(a!), b:\(b!)")
    }
}
var zx = AAA(123, "조인성") //한번만 사용할 것이라면, 굳이 변수로 담지 않아도 된다.

위 예제는 init()의 매개변수와 클래스내의 멤버변수가 이름이 같아 혼동이 될수 있기에 명시적인 목적으로 사용했다.


self 예제 1

각 선분의 길이를 입력받으면 어떤 도형인지, 도형의 넓이, 도형의 둘레를 측정하는 클래스를 작성해보았다. 편의상 사각형은 직각사각형, 삼각형은 직각삼각형으로 취급했다.

class Shape{
    var name:String!
    var line:[Int]!
    var area = 0, border = 0
    
    init(_ line:Int...){    //사용자 정의 생성자 -- 필요한 멤버요소 획득
        self.line = line
        name = ["원","직사각형","직각삼각형"][line.count-1]   //line.count-1은 인덱스를 담당하게된다.
        calc()  //연산
    }
    
    func calc(){
        if name == "원"{
            let pi = 3.14
            self.area = Int(Double(self.line[0]) * Double(self.line[0]) * pi)
            self.border = Int(Double(self.line[0]) * 2.0 * pi)
        } else if name == "직사각형"{
            area = line[0] * line[1]
            border = (line[0] + line[1]) * 2
        } else if name == "직각삼각형"{
            area = line[0] * line[1] / 2
            border = line[0] + line[1] + line[2]
        }
    }
        
    func ppp(){
        print("\(name!): \(area), \(border)")
    }
}
var shapes = [
    Shape(5),
    Shape(5,6),
    Shape(5,6,8),
    Shape(10,20),
    Shape(14,16,21),
    Shape(8)
]

for sh in shapes{
    sh.ppp()
}


self 예제 2

학생클래스를 정의하고 학생 정보를 출력해보았다.

클래스명: Stud

입력내용: 이름,국어,영어,수학

출력정보: 이름,국어,영어,수학,총점,평균

class Stud{
    var name:String
    var kor:Int
    var eng:Int
    var math:Int
    
    var tot = 0
    var avg = 0
    
    init(_ name:String, _ scores:Int...){
        self.name = name
        self.kor = scores[0]
        self.eng = scores[1]
        self.math = scores[2]
        
        calc()
    }
    
    func calc(){
        tot = kor + eng + math
        avg = tot/3
    }
    
    func ppp(){
        print("name:\(name)\t국어:\(kor)\t영어:\(eng)\t수학:\(math)\t총점:\(tot)\t평균:\(avg)")
    }
}
var studs = [Stud("라이언",86,87,89),
            Stud("어피치",77,76,74),
            Stud("프로도",65,66,68),
            Stud("제이지",99,97,95)
            ]

for st in studs{
    st.ppp()
}


Inheritance

Inheritance(상속)는 상위클래스의 요소를 자식클래스가 가져와 사용할 수 있는 객체지향언어의 가장 큰 특징이다. 

상속의 선언은 다음과 같다. 

     class 자식클래스 : 부모클래스 {

          실행코드 ... 

     }

자식클래스는 부모클래스의 멤버변수와 메소드를 사용할 수 있는데, 메소드는 자식클래스의 필요에 따라 overriding(재정의)이 가능하다. 상속을 이용하는 가장 큰 이유이며 이렇게 하나의 메소드가 호출하는 주체에 따라 다르게 동작하는 것을 polimolphism(다형성)이라고 한다.

class Par{
    var a = 10
    var b = "부모"
    
    func fn_1(){
        print("부모 fn_1()")
    }

    func fn_2(){
        print("부모 fn_2()")
    }
}

class Child : Par{  //상속관계 정의(자식 : 부모)
    var c = 3000
    
    override func fn_2(){   //overriding 재정의. 부모의 메소드를 재정의하여 사용한다.
        print("자식 fn_2()")
    }
    
    func fn_3(){
        print("자식 fn_3()")
    }
    
}

class Child2 : Par{  //상속관계 정의(자식 : 부모)
    var d = 4040
    
    func fn_4(){
        print("자식2 fn_4()")
    }
}
var pp = Par()
var cc = Child()
var cc2 = Child2()

print("pp-----------")
print(pp.a,pp.b)
pp.fn_1()
pp.fn_2()

print("cc-----------")
print(cc.c)
print(cc.a,cc.b,cc.c)
cc.fn_3()
cc.fn_1()
cc.fn_2()

print("cc2-----------")
print(cc2.d)
//print(cc2.c)    //Child클래스의 멤버변수에 접근 불가.
print(cc2.a,cc2.b,cc2.d)
//cc2.fn_3()  //Child클래스의 메소드에 접근 불가.
cc2.fn_4()
cc2.fn_1()
cc2.fn_2()

예제를 보면 알 수 있듯이 자식 클래스들은 모두 부모 클래스에 접근이 가능하지만, 서로 다른 자식클래스들은 서로 간에 접근이 불가능하다. 또한 같은 함수를 호출하더라도 overriding이 되어있는지의 여부에 따라 다른 결과물이 출력되는 점도 확인 할 수 있다.


객체지향언어의 꽃이라고 볼 수 있는 상속은 누군가 체계적으로 작성한 클래스를 상속, 재정의하여 본인에게 알맞게 사용 가능하다는 점이 매력적인 기능이다.

'iOS > TJ' 카테고리의 다른 글

day12_funcVariable, selfCall, class  (0) 2021.06.29
day11_param, return, funcCall  (0) 2021.06.18
day10_func()  (0) 2021.06.17
day09_dictionary, set  (0) 2021.06.16
day08_multiArray, tuple  (0) 2021.06.03

local variable, global variable

변수는 함수내에서 선언이 되면 해당 함수가 호출 시에 생성이 되고 함수가 종료되면 소멸된다. 이러한 변수를 지역변수라고 한다. 함수 밖에서 선언이 된 변수는 전역변수라고 부르며 프로그램이 실행되면 생성이 되며 프로그램이 종료되어야 소멸한다. 

var a = 10      //전역변수  -> 함수 내외에서 호출 가능
var b = 20      //전역변수

func fn_1(){
    var c = 3000    //지역변수 -> 해당함수 내에서만 호출 가능, 함수 종료시 소멸.
    print("\t fn_1()시작 a:\(a), b:\(b), c:\(c)")
    a = 11  //전역변수 a 변경
    b = 21  //전역변수 a 변경
    print("\t fn_1()끝 a:\(a), b:\(b), c:\(c)")
}

func fn_2(){
    var d = 4000    //지역변수 -> 해당함수 내에서만 호출 가능, 함수 종료시 소멸.
    print("\t fn_2()시작 a:\(a), b:\(b), d:\(d)") //전역변수 b호출
    a=13    //전역변수 a 변경
    var b = 23  //지역변수 b 선언 -> 우선순위가 전역변수보다 높다.
    print("\t fn_2()끝 a:\(a), b:\(b), d:\(d)")  //지역변수 b 호출
}

func fnTot(){
    var e = 5432
    print("fnTot()시작 a:\(a), b:\(b), e:\(e)")
    fn_1()      //fn_1() 함수를 호출했다 하더라도, fn_1()의 지역변수를 호출할수는 없다.
    print("fnTot()중간 a:\(a), b:\(b), e:\(e)")
    a=12        //전역변수 a 변경
    fn_2()      //fn_2() 함수를 호출했다 하더라도, fn_2()의 지역변수를 호출할수는 없다.
    print("fnTot()끝 a:\(a), b:\(b), e:\(e)")
}

fnTot()

지역변수의 특징은 선언된 함수 내에서만 접근이 가능하다는 점이다. 다른 함수가 호출하였다 하더라도 해당 지역변수에는 접근할 수 없으며, 반대로 전역변수의 경우 어디서든 접근이 가능한 것이 특징이다.


selfCall

selfCall(재귀함수)는 자기 자신을 호출하는 함수를 뜻한다. 반복문과 마찬가지로 탈출조건을 적지 않으면 무한루프에 빠지게 되니 주의깊게 작성해야 한다. 

//재귀함수를 이용하여 0부터 매개변수까지의 합 구하기
var pre = ""
func fn(no:Int) -> Int{
    let myPre = pre
    pre += "\t"
    
    var res = no
    
    print("\(myPre)fn() 시작:\(no), \(res)")
    
    if no > 0 {     //조건
//        let rr = fn(no:no-1) //증감 : -1
//        res += rr
//        print(no, rr, res)
        res += fn(no:no-1)
    }
    
    print("\(myPre)fn() 끝:\(no), \(res)")
    return res
}

var qq = fn(no:3)    //초기값
print("main: \(qq)")

pre변수는 함수의 출력부분을 편하게 구분하기 위해 출력한 것이므로 주의깊게 보지 않아도 된다. fn(3)의 호출 흐름을 간단하게 그려보았다.


class

클래스는 표현하고자 하는 것을 자료형으로 정의한 것이라고 생각하면 된다. 

표현하고자 하는 것의 속성 및 상태를 변수로 표현하고, 그것의 동작을 함수로 표현한다. 이때 클래스에 정의한 변수를 멤버변수, 클래스에 정의한 함수를 메소드라고 지칭한다. 클래스를 정의하고 사용하기까지 4단계를 거친다.

  1. 클래스 정의
  2. 클래스 형의 변수의 선언
  3. 생성잘르 통해 생성 (heap영역에 생성)
  4. 인스턴스 클래스의 호출

클래스 정의

클래스를 정의한다. 멤버변수를 통해 표현하고자 하는 것의 속성과 특징을 서술하고, 메소드를 통해 동작을 표현한다.

class AAA {
    var aa = 10     //멤버변수: 상태
    var tt = "아기상어"     //멤버변수
    
    func fn_1(){        //메소드: 동작
        print("\(aa), \(tt) AAA fn_1() 실행") //해당 클래스의 멤버요소 접근 가능
    }
    
    func fn_2(){        //메소드
        print("AAA fn_2() 실행")
    }
}

클래스형 변수 선언

클래스를 실체화하여 사용하기 위해 변수로 선언한다. 

var a1:AAA  //정의된 클래스를 통해 변수를 선언한다.
var a2:AAA //물론 여러개를 만들 수 있다.

생성

선언한 변수를 사용하기 위해 생성자로 초기화한다.

a1=AAA()    //생성 및 대입
a2=AAA()

인스턴트 클래스 호출 및 접근

변수를 통해 메소드 호출 및 멤버변수에 접근 한다.

print(a1)   //인스턴스 변수 호출 ::> 클래스 타입을 알 수 있다.

print(a1.aa,a1.tt)    //멤버변수 호출
print(a2.aa,a2.tt)    //멤버변수 호출

a1.fn_1()	//메소드 호출
a2.fn_1()	//메소드 호출

a1.aa = 123     //멤버변수에 값 대입
a1.tt = "아빠상어"  //멤버변수에 값 대입

print("a1.aa:",a1.aa,"/ a1.tt:",a1.tt)    //멤버변수 호출
print("a2.aa:",a2.aa,"/ a2.tt:",a2.tt)    //멤버변수 호출

print("-----------------")

a1.fn_1()   //메소드 호출
a1.fn_2()   //메소드 호출

a2.fn_1()
a2.fn_2()

실행 결과를 보면 멤버변수는 각 독립된 존재인 것을 알 수 있다.


클래스 예제

클래스를 통해 입력받은 점수로 합계와 평균을 구하는 클래스를 생성해보았다.

class Exam{     //클래스명은 대문자로 시작한다.
    var name = ""
    var score = [Int]()
    var tot = 0, avg = 0
    
    func first(_ nn:String, _ jj:Int...){
        //1.입력부
        self.name = nn
        self.score = jj
        
        //2.계산부
        self.calc()
        
        //3.출력부
        self.ppp()
    }
    
    func calc(){
        tot = 0
        for i in score{
            tot += i
        }
        avg = tot / score.count
    }
    
    func ppp(){
        print("\(name)\t\(score)\t총점:\(tot)\t평균:\(avg)")
    }
}

비중있게 보아야 할 부분이라면 first()함수에서 매개변수의 값을 멤버변수에 옮겨 담은 후, calc()함수와 ppp()함수를 호출하여 한번에 입력, 계산, 출력을 동작하게 하는 부분이다. 코드가 짧다면 굳이 함수를 나눌 필요없이 first()함수 안에 다른 코드들을 적으면 되지만, 함수의 내용이 커지면 예제와 같이 분리하여 작성하는 것이 분업, 코드의 유지보수에도 더 편리하다. 

var st1 = Exam()	//Exam()형태의 변수 생성
var st2 = Exam()

st1.first("한가인", 77,78,71)  //입력과 동시에 출력.
st2.first("두가인", 87,88,81)

'iOS > TJ' 카테고리의 다른 글

day13_initializer, self, inheritance  (0) 2021.07.01
day11_param, return, funcCall  (0) 2021.06.18
day10_func()  (0) 2021.06.17
day09_dictionary, set  (0) 2021.06.16
day08_multiArray, tuple  (0) 2021.06.03

parameter

함수의 호출 시 parameter(매개변수)는 모두 적어야한다. 하지만 함수를 정의할 때 매개변수의 기본값을 명시해 놓으면 호출시에 매개변수를 명시하지 않아도 기본값으로 대입된다. 

func fn_1 (name:String, age:Int, marriage:Bool){
    print("name:\(name), age:\(age), marriage: \(marriage)")
}

func fn_2 (name:String, age:Int=21, marriage:Bool = false){    //marriage, age에 기본값 설정
    print("name:\(name), age:\(age), marriage: \(marriage)")
}

fn_1(name:"차은우", age:34, marriage: false)//기본값을 명시하지 않아 인수를 모두 명시해야한다.
fn_2(name:"차은수", age:24)    //기본값이 입력되어있는 매개변수는 인수를 작성하지 않아도 된다.
fn_2(name:"차은미")    //기본값이 입력되어있는 매개변수는 인수를 작성하지 않아도 된다.

fn_1()과 달리 fn_2()는 매개변수에 기본 값이 설정되어 있기에 호출 시 생략이 가능하다.

func exam(name:String, type:String = "일반", kor:Int, eng:Int, art:Int){
    var res = 0
    if type == "일반"{	//type이 일반일 경우와 아닐경우를 나누어서 점수를 계산한다.
        res = (kor + eng + art)/3
    } else {
        res = Int((Double(kor)*0.3) + (Double(eng)*0.2) + (Double(art)*0.5))
    }
    
    print("\(type) \(name) : \(res)")
}

exam(name: "차금우", kor: 87, eng: 90, art: 30)    //기본값인 일반으로 계산
exam(name: "차동우", type: "특기생", kor: 87, eng: 90, art: 30)   //일반이 아닌 다른 경우로 계산

이어서 매개변수에는 가변매개변수가 있다. 자료형 뒤에 ...을 붙여 명시하며 이는 호출 시 연속하여 자료를 입력받고, 이를 배열로 처리한다. 호출시에 배열형태로 입력을 받으면 에러가 일어난다는 점을 기억하자.

func fn_3(id:String, size:[Int]){   //매개변수를 배열로 받음
    print("id: \(id), size: \(size)")
}

func fn_4(id:String, size:Int...){  //정수형 가변매개변수
    print("id: \(id), size: \(size)")
}

fn_3(id:"aaa", size: [5,7,2,3,9])
//fn_3(id:"aaa", size: 5,7,2,3,9)   //배열형태가 아니어서 에러


fn_4(id:"ccc", size: 5,7,2,3,9)     //입력 정수들을 알아서 배열로 묶어준다. 매개변수의 갯수에 따라 다른 연산도 가능하다.
//fn_4(id:"ccc", size: [5,7,2,3,9])   배열형태면 에러.


가변매개변수 예제

가변매개변수를 사용하여 각 다른 과목수의 평균, 합계를 구한다.

//Q.숫자들을 입력하여 총점, 평균을 출력하는 함수를 구현하세요.
func res(_ score:Int...){
    var result = 0
    
    for i in score{
        result += i
    }
    
    print("총점:",result, "평균:",result/score.count)
}
res(67,62,66,65,68)
res(77,75,73)


return

함수는 크게 4가지 종류로 나뉜다.

  • 매개변수와 return이 있는 함수
  • 매개변수는 있지만 return이 없는 함수
  • 매개변수가 없지만 return이 있는 함수
  • 둘 다 없는 함수 

여기서 return에 대해서 이야기 해본다면 return이 없는 함수의 경우 4가지 방법으로 정의할 수 있다.

func fn_1(){
    print("fn_1 () 실행 1")
    print("fn_1 () 실행 2")
    print("fn_1 () 실행 3")
    print()
}

func fn_2(){
    print("fn_2 () 실행 1")
    print("fn_2 () 실행 2")
    print("fn_2 () 실행 3")
    print()
    return;     //reutrn;은 항상 생략되어있다.
}

func fn_3() -> Void{    //return이 없다는 뜻이다.
    print("fn_3 () 실행 1")
    print("fn_3 () 실행 2")
    print("fn_3 () 실행 3")
    print()
    return;     //reutrn;은 항상 생략되어있다.
}

func fn_4() -> (){    //return이 없다는 뜻이다.
    print("fn_4 () 실행 1")
    print("fn_4 () 실행 2")
    print("fn_4 () 실행 3")
    print()
    return;     //reutrn;은 항상 생략되어있다.
}


fn_1()
fn_2()
fn_3()
fn_4()

return; 문구는 별다른 반환없이 종료한다는 얘기이다. 그렇다면 return; 문구는 함수 중간에 적어보겠다.

func fn_5(){    //return이 없다는 뜻이다.
    print("fn_5 () 실행 1")
    print()
    return;     //여기서 함수가 종료된다. 즉 return은 함수의 탈출을 뜻한다.
    print("fn_5 () 실행 2")
    print()
    return;
    print("fn_5 () 실행 3")
    print()
    return;
}

fn_5()	//함수실행

실행1부분만 출력되고 그 이후는 함수가 종료된다. 즉 return; 은 함수의 탈출을 의미한다.

func fn_6(_ num : Int){
    if num >= 88{
        print("fn_6(): 우수")
        print()
        return;
    }
    
    if num >= 60{
        print("fn_6(): 정상")
        print()
        return;
    }
    
    print("fn_6(): 미달")
    print()
    return;
}
fn_6(59)    //미달
fn_6(89)    //우수
fn_6(66)    //정상

이런식으로 조건문을 사용하여 함수의 종료시점을 정해줄 수 있다는 것이다.


일반적으로 return은 하나의 자료만 반환이 가능하다. 그렇다면 여러 자료를 반환하려면 어떻게 하면될까?

func fn_7() -> Int {
    print("fn_7() : 실행")
    return 100
}

func fn_8() -> [Int] {
    print("fn_8() : 실행")
    return [100,200]
}

func fn_9() -> (String,Int) {
    print("fn_9() : 실행")
    return ("아기상어",200)
}

var rr = fn_7()
print("rr: \(rr)"); print()

var rr2 = fn_8()
print("rr2: \(rr2)"); print()

var rr3 = fn_9()
print("rr3: \(rr3)"); print()

//튜플을 리턴받아 대입에 사용할 수 있다.
var ss:String
var ii:Int
(ss,ii) = fn_9()
print("ss:\(ss), ii:\(ii)"); print()

배열이나 튜플과 같이 시퀀스자료를 반환하면 여러자료를 반환할 수 있고, 이러한 반환을 대입에도 사용할 수 있다.


return 예제1

가변매개변수로 연속하여 자료를 받고, 해당 매개변수에서 가장 큰 값과 작은 값을 리턴하는 함수이다.

typealias numType = (max:Int, min:Int)
func max_min(_ nums:Int...) -> numType{     //typealias로 묶어서 반환이 가능하다.
    
    if nums.count == 0{     //빈배열이 들어온다면?
        print("연산불가")
        return(0,0);
    }
    
    var max = nums[0]   //첫번째 수로 초기화 -> 처음에 비교할 기준이 필요하기 때문
    var min = nums[0]   //첫번째 수로 초기화
    
    for i in nums{	//대소비교 시작
        if max < i {
            max = i
        }
        if min > i {
            min = i
        }
    }
    
    return (max, min)	//numType으로 리턴
}

var ret = max_min(67,32,98,2,15,65,3,76)
print("최대: \(ret.max)")
print("최소: \(ret.min)");
print("--------------------------")

var rrr = max_min()
print("최대: \(rrr.max)")
print("최소: \(rrr.min)")


return 예제2

num의 배수에 해당하는 숫자들을 리턴하는 함수를 구현하세요
mulArr(num:3, 45,56,67,78,76,12,34,26)

func mulArr(num:Int, _ nums: Int...) -> [Int]{
    var res = [Int]()
    
    for i in nums{
        if i%num == 0{  //배열속의 숫자가 num으로 나누어지면 res배열에 추가.
            res.append(i)
        }
    }
    
    print("\(num)의 배수는 \(res)입니다.")
    return res;
}
print(mulArr(num:3, 45,56,67,78,76,12,34,26))


funcCall

함수는 다른 함수를 호출할 수 있다.

func fnTot(){
    var aa = 10
    print("fnTot() 실행 1 \(aa)")
    fn_1()      //함수 내에서 함수를 호출한다.
    print("fnTot() 실행 2 \(aa)") //여기서는 fn_1()의 bb를 호출할 수 없다.
    fn_2()      //함수 내에서 함수를 호출한다.
    print("fnTot() 실행 3 \(aa)")
}

func fn_1(){
    var bb = 20
    print("fn_1() 실행 \(bb)")  //여기선 fnTot()의 aa를 호출할 수 없다.
}
func fn_2(){
    print("fn_2() 실행 ")
}

fnTot()	//fnTot()호출

여기서 알아두어야 할 점은 fnTot()에서 fn_1()을 호출했다 하더라도 fnTot()에서는 fn_1()에서 선언된 변수 bb에 접근 할 수 없다는 것이다. 함수는 각각 정해진 영역을 가지고 동작하며, 이러한 특성을 생각해서 변수의 지정과 선언을 잘해야한다.

'iOS > TJ' 카테고리의 다른 글

day13_initializer, self, inheritance  (0) 2021.07.01
day12_funcVariable, selfCall, class  (0) 2021.06.29
day10_func()  (0) 2021.06.17
day09_dictionary, set  (0) 2021.06.16
day08_multiArray, tuple  (0) 2021.06.03

function

함수(function)는 프로그램의 가장 작은 단위이자 하나의 작은 프로그램이다. 함수를 사용하는 데에는 크게 두가지 이유가 있다. 첫번째는 작업단위의 모듈화. 두번째는 재사용의 용이성이다. 

함수는 미리 정의한 뒤, 호출을 통해서 사용할 수 있다. 다음은 함수의 정의 표현이다.

     func 함수이름 (매개변수:자료형 ... ) -> 리턴타입 {

          실행구문

          return 반환값

     }

매개변수에는 자료형을 명시해야하며 함수에 매개변수, 리턴타입이 없다면 생략이 가능하다. 다음은 함수의 호출형식이다.

     함수명(인수1, 인수2, ... )

     변수 = 함수명(인수1, 인수2, ... )

함수의 호출 시 인수의 순서는 바뀌면 안되며 반드시 함수의 매개변수에 맞게 인수를 적어야한다.

//함수정의
func fn_1(aa:Int, bnbn bb:String) -> Int{
    print("fn_1() 실행1 \(aa)")   //함수실행코드
    print("fn_1() 실행2 \(bb)")   //매개변수는 지역변수로 활용된다.
    print("fn_1() 실행3")
    
    return 1234 //리턴
}

var rr = fn_1(aa:10, bnbn:"아기상어")	//함수호출
print("rr: \(rr)")  //리턴 값 확인

fn_1()함수에 매개변수를 보면 bnbn bb : String이라 되어있다. 스위프트의 함수가 다른언어들과의 차이점이 매개변수와 인수를 따로 구분한다는 점이다. bnbn은 인수, 즉 외부에서 호출 시의 매개변수를 부르는 이름이다. 반대로 함수 내부에서는 bnbn이 아닌 bb로 사용해야 매개변수로서 접근이 가능하다. 코딩시 영어문장처럼 흘러가도록 하기위해 이와 같이 매개변수와 인수를 따로 구분하는 것으로 알고있다. 해당 문법이 불편하면 매개변수만 적게되으면 된다. 인수와 매개변수를 통일하여 사용 할 수 있다.

fn_1(aa: 20, bnbn: "아빠상어"); 
fn_1(aa: 678, bnbn: "엄마상어")
fn_1(aa: 1920, bnbn: "할머니상어")

이와 같이 함수를 사용하게 되면 반복작업을 손쉽게 처리할 수 있다.


label 생략

label(인수)은 생략이 가능하다. 인수명을 언더바로 적으면 호출 시에 인수명을 따로 적지 않고 바로 입력하여 함수를 호출 할 수 있다.

func fn_1(name:String, age:Int, marriage:Bool){
    print("fn_1() name:\(name), age:\(age), marriage:\(marriage)")
}

func fn_2(_ name:String, aa age:Int, mm marriage:Bool){
    print("fn_2() name:\(name), age:\(age), marriage:\(marriage)")
}

func fn_3(_ name:String, _ age:Int, _ marriage:Bool){
    print("fn_3() name:\(name), age:\(age), marriage:\(marriage)")
}

//fn_1(name: "정우성", marriage: false, age: 51) //인수의 순서는 바꾸면 안된다.
fn_1(name: "정우성", age: 51, marriage: false) //스위프트의 함수는 호출 시 인수(label)를 적어야 한다.
fn_2("정좌성", aa:51, mm:false)    //인수(label)를 언더바(_)로 생략처리하면 인수를 적으면 안된다.
fn_3("정남성", 51, false)


func 예제

정수형 배열을 매개변수로 받아 그 중 가장 작은 값을 반환하는 함수를 작성해보았다.

func minGo(arr:[Int]) -> Int{
    var res = arr[0]	//매개변수로 배열의 첫번째 요소를 res변수에 담는다. 
    
    for i in arr{
        if res > i {
            res = i	//res의 값보다 더 작은 값의 요소를 찾으면 res에 대입한다.
        }
    }
    return res		//res값을 반환한다.
}

var res = minGo(arr: [34,56,7,12,4,98,23,167,11])
print("res:",res)

'iOS > TJ' 카테고리의 다른 글

day12_funcVariable, selfCall, class  (0) 2021.06.29
day11_param, return, funcCall  (0) 2021.06.18
day09_dictionary, set  (0) 2021.06.16
day08_multiArray, tuple  (0) 2021.06.03
day07_array  (0) 2021.06.02

+ Recent posts