이 게시글은 애플 실리콘을 사용하는 M1과 M2에게 해당되는 해결방법입니다! 이 게시글은 언젠가 포맷을 하게된 미래의 niraaah를 위해 작성되었습니다.

1. 파일 다운로드 해서 해당 파일 압축 해제
2. 파인더 새 창 열어서 경로 이동: /사용자/[본인의 사용자 이름]/라이브러리/Application Support/Steam/steamapps/common/Stardew Valley/Contents/MacOS
3. 2번의 경로에 있는 파일들 중 "libSDL2-2.0.0.dylib" 라는 이름을 가진 파일 찾아서 이름 변경: "libSDL2-2.0.0.dylib" > "libSDL2-2.0.0.dylib.orig" (뭔가 문제가 되었을 때 추가했던 파일을 삭제하고 이름 바꿨던 파일의 이름에서 ".orig"만 지워주면 원상복구가 가능하게 하기 위함임. 이름을 변경하지 않고 기존 파일을 아얘 지워버려도 상관은 없을 듯 하지만 절대 권장하지 않음)
4. 1번에서 압축 해제해둔 "libSDL2-2.0.0.dylib" 파일을 2번의 경로에 옮겨준다.
5. 스듀를 정상적으로 재실행시켜보면... 해결 완!

출처: 스타듀밸리 포럼

# IndexError 예외: 리스트의 길이를 넘는 인덱스로 요소에 접근하고자 할 때 발생

# ---------------------------------------- #

listA = [1,2,3]
listB = [4,5,6]

print(listA + listB) # [1,2,3,4,5,6]
print(listA * 3) # [1,2,3,1,2,3,1,2,3]
print(len(listA)) # 3

listA.extend(listB) # (연결 연산자 '+' 와 달리) '파괴적 처리'
print(listA) # [1,2,3,4,5,6]

# ---------------------------------------- #

listA = [1,2,3]
listB = [4,5,6]
listC = [4,5,6]

listA.append(4) # 리스트 뒤에 요소 추가
print(listA) # [1,2,3,4]

# 비교하기) 둘 다 '파괴적 처리'다.
# listB.append(listA) -> [4,5,6,[1,2,3]]
# listC += listA -> [4,5,6,1,2,3]

listA.insert(0,10) # 리스트 중간에 요소 추가
print(listA) # [10,1,2,3,4] 

# ---------------------------------------- #

#인덱스로 요소 제거

listA = [0,1,2,3,4,5]

del listA[1]
print(listA) # [0,2,3,4,5]

listA.pop()
print(listA) # [0,2,3,4]
listA.pop(2)
print(listA) # [0,2,4]

listB = [0,1,2,3,4,5,6]
listC = [0,1,2,3,4,5,6]
listD = [0,1,2,3,4,5,6]

del listB[3:6]
print(listB) # [0,1,2,6]
del listC[:3]
print(listC) # [3,4,5,6]
del listD[3:]
print(listD) # [0,1,2]

# ---------------------------------------- #

# <슬라이싱>
# 형식>> 리스트_이름 [ 시작_인덱스 : 끝_인덱스 : 단계 ]

numbers1 = [1,2,3,4,5,6,7,8]
numbers2 = [1,2,3,4,5,6,7,8]

print(numbers1[0:5:2]) # [1,3,5]
print(numbers2[::-1]) # [8,7,6,5,4,3,2,1]

# ---------------------------------------- #

# 값으로 제거

listA = [1,2,1,2]
listB = [0,1,2,3,4,5]

listA.remove(2)
print(listA) # [1,1,2]
# 리스트에 중복된 여러개의 값을 모두 제거하려면 반복문과 조합해서 사용해야함
# while 2 in listC:
#     listC.remove(2)
#     print(listC)

listB.clear()
print(listB) # []

# ---------------------------------------- #

# 요소 정렬하기

listA = [52, 273, 103, 32, 275, 1, 7]
listA.sort() # 오름차순
print(listA) # [1,7,32,52,103,273,275]
listA.sort(reverse = True) # 내림차순
print(listA) # [275,273,103,52,32,7,1]

# ---------------------------------------- #

# in / not in 연산자
# 특정 값이 내부에 있는지 확인

listA = [273,32,103,57,52]

print(273 in listA) # True
print(10 in listA) # False
print(273 not in listA) # False
print(10 not in listA) # True

# ---------------------------------------- #

# for와 리스트

array = [273,32,103,57,52]

for element in array:
    print(element)
# 출력 결과:
# 273
# 32
# 103
# 57
# 52

for character in "안녕하세요":
    print("-", character)
# 출력 결과:
# - 안
# - 녕
# - 하
# - 세
# - 요

listOfList = [
    [1,2,3],
    [4,5,6,7],
    [8,9]
]

for items in listOfList:
    for item in items:
        print(item)
# 출력 결과:
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9

# ---------------------------------------- #

# 전개 연산자 '*'

listA = [1, 2, 3, 4]

listB = [*listA, *listA]
listC = [*listA, 5]
listD = [listA, listA]

print(listA) # [1, 2, 3, 4]
print(listB) # [1, 2, 3, 4, 1, 2, 3, 4]
print(listC) # [1, 2, 3, 4, 5]
print(listD) # [[1, 2, 3, 4], [1, 2, 3, 4]]


# ---------------------------------------- #

# min(리스트_이름): 리스트 내부의 최솟'값' 반환
# max(리스트_이름): 리스트 내부의 최댓'값' 반환

>>> max(iterable, *iterables, key=None, default=None)
>>> min(iterable, *iterables, key=None, default=None)

- iterable: 찾을 대상인 하나의 반복 가능한 객체 (필수)
- *iterables: 추가적인 iterable (선택)
- key: 함수를 인자로 받아 각 요소의 정렬 순서를 결정하는데 사용
- default: itrable이 비어있을 때 반환될 값 (비 지정시 ValueError 발생)

# sum(리스트_이름): 리스트 내부의 값을 모두 더한 '값'을 반환

# ---------------------------------------- #

# reversed(리스트_이름): 뒤집어진 '이터레이터'를 반환
# 반환 결과가 '리스트'가 아님을 기억하자!

numbers = [1,2,3,4,5]
for i in reversed(numbers):
    print('반복문: {}'.format(i))

# 실행 결과
# 반복문: 5
# 반복문: 4
# 반복문: 3
# 반복문: 2
# 반복문: 1

# ---------------------------------------- #

# enumerate(리스트_이름)
# : 리스트의 요소를 반복할 때 인덱스가 몇 번째인지 확인하기 위해 사용 

exampleList = ['A','B','C']

print('# 단순 출력')
print(exampleList)
print('-')

print('# enumerate()함수 적용')
print(enumerate(exampleList))
print('-')

print('# list() 함수로 강제 변환 출력')
print(list(enumerate(exampleList)))
print('-')

print('# 반복문과 조합하기')
for i, value in enumerate(exampleList): # for 와 in 사이에 변수가 두 개가 들어감
    print('{}번째 요소는 {}입니다.'.format(i,value))

# 출력 결과

# # 단순 출력
# ['A', 'B', 'C']
# -
# # enumerate()함수 적용
# <enumerate object at 0x000001E037044DC0>
# -
# # list() 함수로 강제 변환 출력
# [(0, 'A'), (1, 'B'), (2, 'C')]
# -
# # 반복문과 조합하기
# 0번째 요소는 A입니다.
# 1번째 요소는 B입니다.
# 2번째 요소는 C입니다.

[리스트 내포]

# 리스트_이름 = [ 표현식 for 반복자 in 반복할_수_있는_것 ]
# 리스트_이름 = [ 표현식 for 반복자 in 반복할_수_있는_것 if 조건문 ]

array1=[]
for i in range(0,20,2):
    array1.append(i * i)
print(array1)

# 대신

array2 = [i * i for i in range(0,20,2)]
# 해석: range(0,20,2)의 요소를 i라고 할 때 i * i로 리스트를 재조합해 줘
print(array2)

# ---------------------------------------- #

array = ['apple','plum','chocolate','banana','cherry']

# output = [fruit for fruit in array if fruit != 'chocolate'] 또는
output = [fruit 
    for fruit in array 
    if fruit != 'chocolate']

print(output) # ['apple', 'plum', 'banana', 'cherry']

[딕셔너리] : ‘키’를 기반으로 값을 저장

myDic = {
    "name" : "7D mango",
    "type" : "fruit",
    "ingredient" : ["mango", "sugar", "salt", "color"],
    "origin" : "Philippines"
}

print("name:",myDic["name"])
print("type:",myDic["type"])
print("ingredient:",myDic["ingredient"])
print(myDic["ingredient"][1])
print("origin:",myDic["origin"])
print()

# 출력 결과
# name: 7D mango
# type: fruit
# ingredient: ['mango', 'sugar', 'salt', 'color']
# sugar
# origin: Philippines

myDic["name"] = "8D mango" # 값을 수정
print("name:",myDic["name"]) # name: 8D mango

myDic["price"] = 5000 # 키와 값을 추가
print(myDic)

# 출력 결과
# {'name': '8D mango', 'type': 'fruit',
# 'ingredient': ['mango', 'sugar', 'salt', 'color'],
# 'origin': 'Philippines', 'price': 5000}

del myDic['type'] # 키와 값을 제거
print(myDic)

# 출력 결과
# {'name': '8D mango', 'type': 'fruit',
# 'ingredient': ['mango', 'sugar', 'salt', 'color'],
# 'origin': 'Philippines'}

# ---------------------------------------- #

myDic = {}
print('요소 추가 이전:',myDic)
myDic['name'] = 'new name'
myDic['head'] = 'new spirit'
myDic['body'] = 'new body'

print('요소 추가 이후:',myDic)

# 출력 결과
# 요소 추가 이전: {}
# 요소 추가 이후: {'name': 'new name', 'head': 'new spirit', 'body': 'new body'}

# ---------------------------------------- #

# KeyError : 존재하지 않는 키에 접근시 발생

# ---------------------------------------- #

myDic = {
    "name" : "7D mango",
    "type" : "fruit",
    "ingredient" : ["mango", "sugar", "salt", "color"],
    "origin" : "Philippines"
}

key = input('> 접근하고자 하는 키: ')

if key in myDic:
    print(myDic[key])
else:
    print("존재하지 않는 키에 접근하고 있습니다.")

# ---------------------------------------- #

# get() : '딕셔너리_이름 [ 키 ]' 와 같은 기능을 하는데
# 존재하지 않는 키에 접근할 경우 KeyError 발생 대신 None 출력

value = myDic.get('존재하지 않는 키')
print('값:',value)

if value == None:
    print("존재하지 않는 키에 접근했었습니다.")

# 출력 결과
# 값: None
# 존재하지 않는 키에 접근했었습니다.

# ---------------------------------------- #

# for문과 딕셔너리

for key in myDic:
    print(key,':',myDic[key])

# 출력 결과
# {'name': '8D mango', 'type': 'fruit',
# 'ingredient': ['mango', 'sugar', 'salt', 'color'],
# 'origin': 'Philippines'}

# ---------------------------------------- #

# 딕셔너리_이름.item() 활용

exDic = {
    'keyA':'valueA',
    'keyB':'valueB',
    'keyC':'valueC'
}

print(exDic.items())

# 출력 결과
# dict_items([('keyA', 'valueA'), ('keyB', 'valueB'), ('keyC', 'valueC')])

for key, element in exDic.items():
    print(key,':',element)

# 출력 결과
# keyA : valueA
# keyB : valueB
# keyC : valueC

[역반복문]

for i in range(4,-1,-1): # range(4,0-1,-1)  표현으로 강조할 수도 있음
    print("현재 반복 변수: {}".format(i))

for i in reversed(range(5)):
    print("현재 반복 변수: {}".format(i))

# 실행 결과
# 현재 반복 변수: 4
# 현재 반복 변수: 3
# 현재 반복 변수: 2
# 현재 반복 변수: 1
# 현재 반복 변수: 0

[중첩 반복문으로 별 쌓기]

output = ''

for i in range(1,11):
    for j in range(i):
        output+='*'
    output += '\n'

print(output)

# 출력결과
# *
# **
# ***
# ****
# *****
# ******
# *******
# ********
# *********
# **********

# ---------------------------------------- #

output = ''
for i in range(1,11):
    for j in range(11-i):
        output += ' '
    for k in range(2 * i - 1):
        output += '*'
    output += '\n'
print(output)

# 출력 결과
#           *
#          ***
#         *****
#        *******
#       *********
#      ***********
#     *************
#    ***************
#   *****************
#  *******************

[시간 기반 반복]

import time
number = 0

targetTick = time.time() + 5
while time.time() < targetTick:
    number += 1
print('5초 동안 {}번 반복했습니다.'.format(number))

# 출력 결과
# 5초 동안 29396701번 반복했습니다.

# ---------------------------------------- #

#10초 타이머 만들기

import time

count = 1
maxTime = time.time() + 10
while True:
    time.sleep(1)
    print(count)
    if time.time() > maxTime:
        break
    count += 1

[break / continue]

i = 1
while True:
    print('{}번째 반복문입니다.'.format(i))
    i += 1
    inputText = input('> 종료하시겠습니까?(y/n): ')
    if inputText in ['y','Y']:
        print('반복을 종료합니다')
        break

# 'y' 또는 'Y'가 입력될 때까지 반복
# 'y' 또는 'Y'가 입력되면 프로그램 종료

# ---------------------------------------- #

# 이중 루프 탈출

i = 1
while True:
    print('{}번째 반복문입니다.'.format(i))
    i += 1
    while True:
        inputText = input('종료하시겠습니까? (y/n) : ')
        if inputText in ['y','Y']:
            print('반복을 종료합니다.')
            break
        elif inputText in ['n', 'N']:
            break
        else:
            print('올바른 입력이 아닙니다!')
            continue
    if inputText in ['y', 'Y']:
        break

# ---------------------------------------- #

numbers = [5,15,6,20,7,25]

for number in numbers:
    if number < 10:
        continue
    print(number)

# 출력 결과
# 15
# 20
# 25

[여러 줄의 문자열 처리]

test = (
    '이렇게 입력해도 '
    '하나의 문자열로 연결되어 '
    '생성됩니다.'
)

print(test) # 이렇게 입력해도 하나의 문자열로 연결되어 생성됩니다.
print(type(test)) # <class 'str'>

# ---------------------------------------- #

# 문자열.join(문자열로_구성된_리스트)

print('::'.join(['1','2','3','4','5'])) # 1::2::3::4::5

# 응용:
number = int(input('정수 입력> '))

if number % 2 == 0:
    print('\n'.join([
        '입력한 문자열은 {}입니다.',
        '{}는(은) 짝수입니다.'
    ]).format(number, number))
else:
    print('\n'.join([
        '입력한 문자열은 {}입니다.',
        '{}는(은) 홀수입니다.'
    ]).format(number, number))

# 더 간단하게는

number = int(input('정수 입력>> '))

answer = [
        '입력한 문자열은{}입니다',
        '{}는(은) {}입니다.'
    ]
if number % 2 == 0:
    print('\n'.join(answer).format(number, number, 'even'))
else:
    print('\n'.join(answer).format(number, number, 'odd'))

[이터레이터]

# reversed() 함수와 이터레이터

numbers = [1,2,3,4,5,6]
rNum = reversed(numbers)

print(rNum)
print(next(rNum))
print(next(rNum))
print(next(rNum))
print(next(rNum))
print(next(rNum))
print(next(rNum))

# 실행 결과
# <list_reverseiterator object at 0x000001E037012D90>
# 6
# 5
# 4
# 3
# 2
# 1

[가변 매개변수 함수]

def printNtimes(n, *values):
    for i in range(n):
        for value in values:
            print(value)
        print('-') 
printNtimes(3, 'hello', 'world', 'good', 'morning')
print()
def printNtimes(n, *values):
    for i in range(n):
        for value in values:
            print(value)
        print('-') 
printNtimes(3, ['hello', 'world', 'good', 'morning'])
print()
def printNtimes(n, values):
    for i in range(n):
        for value in values:
            print(value)
        print('-')

printNtimes(3, ['hello', 'world', 'good', 'morning'])

# 출력 결과
# hello
# world
# good
# morning
# -
# hello
# world
# good
# morning
# -
# hello
# world
# good
# morning
# -
# 
# ['hello', 'world', 'good', 'morning']
# -
# ['hello', 'world', 'good', 'morning']
# -
# ['hello', 'world', 'good', 'morning']
# -
# 
# hello
# world
# good
# morning
# -
# hello
# world
# good
# morning
# -
# hello
# world
# good
# morning
# -

[키워드 매개변수]

def printNtimes(*values, n = 2):
    for i in range(n):
        for value in values:
            print(value)
        print('-')

printNtimes('hello,','world!','good','morning!',n = 3)

# 출력 결과
# hello,
# world!
# good
# morning!
# -
# hello,
# world!
# good
# morning!
# -
# hello,
# world!
# good
# morning!
# -

# ---------------------------------------- #

def test(a,b = 10,c = 100):
    print(a + b + c)

# a는 일반 매개변수이므로 해당 위치에 반드시 입력해야함
# 기본 매개변수는 필요한 것만 키워드를 지정해서 입력해주는 편

test(10,20,30) 
test(a = 10,b = 100,c = 200)
test(c = 10,a = 100,b = 200)
test(10,c = 200)

# 출력 결과
# 60
# 310
# 310
# 220

# ---------------------------------------- #

def sumAll(start = 0,end = 100,step = 1):
    output = 0
    for i in range(start,end + 1,step):
        output += i
    return output

print('a.',sumAll(10,70,10))
print('b.',sumAll(end = 99))
print('c.',sumAll(end = 99,step = 2))

# 출력 결과
# a. 280
# b. 4950
# c. 2450

[리스트 평탄화]

def flatten(data):
    output = []
    for item in data:
        if type(item) == list:
            output += flatten(item)
        else:
            output.append(item)
    return output

example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
print('원본: {}'.format(example))
print('변환: {}'.format(flatten(example)))

# 출력 결과:
# 원본: [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
# 변환: [1, 2, 3, 4, 5, 6, 7, 8, 9]

• 함수의 변수는 함수 호출마다 따로따로 만들어진다.
• 함수가 끝나면 (리턴 되면) 함수를 호출했던 위치로 돌아옵니다.

[튜플]

# 괄호를 생략해도 튜플로 인식할 수 있는 경우는 괄호를 생략해도 된다.
tupleTest = 10, 20, 30, 40
print('tupleTest: {}'.format(tupleTest))
print('type(tupleTest): {}'.format(type(tupleTest)))

a, b, c = 10, 20, 30
print("a: {}, b: {}, c: {}".format(a, b, c))

# ---------------------------------------- #

****# 함수의 리턴에 튜플을 사용하면 여러 개의 값을 리턴하고 할당할 수 있다.
def test():
    return (10, 20)
a, b = test()

print('a: {}, b: {}'.format(a, b))****

# ---------------------------------------- #

# <튜플의 활용>

for i, value in enumerate(['a', 'b', 'c', 'd', 'e', 'f']):
    print('{}번째 요소는 {}입니다.'.format(i, value))

# 출력 결과:
# 0번째 요소는 a입니다.
# 1번째 요소는 b입니다.
# 2번째 요소는 c입니다.
# 3번째 요소는 d입니다.
# 4번째 요소는 e입니다.
# 5번째 요소는 f입니다.

# ---------------------------------------- #

# 몫과 나머지를 구하는 divmod() 함수: 튜플을 리턴

a, b = 97, 40
print(divmod(a, b))
x, y = divmod(a, b)
print('x: {}, y: {}'.format(x, y))

# 출력 결과
# (2, 17)
# x: 2, y: 17

[콜백 함수]

: 함수의 매개변수에 사용하는 함수

# 매개변수로 받은 함수를 10번 호출
def call_3_times(func):
    for i in range(3):
        func()
def printHello():
    print('Hello')

# 조합하기
call_3_times(printHello)

# 출력 결과:
# Hello
# Hello
# Hello

[람다]

# map(): 리스트의 요소를 함수에 넣고 리턴된 값으로 새로운 리스트를 구성
# filter(): 리스트의 요소를 함수에 넣고 리턴된 값이 True인 것으로, 새로운 리스트를 구성
# 형식: map(함수_명, 리스트_명) | filter(함수_명, 리스트_명)

def power(item):
    return item * item
def under3(item):
    return item < 3

# 대신

power = lambda x: x * x
under3 = lambda x: x < 3

# 람다 사용법 >> lambda 매개변수_명 : 리턴값

listInputA = [1,2,3,4,5]

outputA = map(power, listInputA)
print('map(power, listInputA):', outputA)
print('map(power, listInputA):', list(outputA))

outputB = filter(under3, listInputA)
print('filter(under3, listInputA):', outputB)
print('filter(under3, listInputA):', list(outputB))

# 출력 결과:
# map(power, listInputA): <map object at 0x000001D4560B7C70>
# map(power, listInputA): [1, 4, 9, 16, 25]
# filter(under3, listInputA): <filter object at 0x000001D456C4B7C0>
# filter(under3, listInputA): [1, 2]

# ---------------------------------------- #

# 인라인 람다
# 함수를 선언하지도 않고 매개변수로 바로 입력

outputA = map(lambda x: x * x, listInputA)
outputB = filter(lambda x: x < 3, listInputA)

[파일 입출력]

# <쓰기>

file = open('basic.txt', 'w')
file.write('Hi there!')
file.close()
# 또는
with open('basic.txt', 'w') as file:
    file.write('Hi there!')

# ---------------------------------------- #

# <읽기>

file = open('basic.txt', 'r')
contents = file.read()
print(contents)
# 또는
with open('basic.txt', 'r') as file:
    contents = file.read()
print(contents)

# ---------------------------------------- #

import random as rand

hanguls = list('가나다라마바사아자차카타파하')

with open('info.txt', 'w') as file:
    for i in range(1000):
        name = rand.choice(hanguls) + rand.choice(hanguls)
        weight = rand.randrange(40, 100)
        height = rand.randrange(140, 200)

        file.write('{}, {}, {}\n'.format(name, weight, height))

with open('info.txt', 'r') as file:
    for line in file:
        (name, weight, height) = line.strip().split(',')

        # 데이터가 문제가 없는지 확인합니다: 문제가 있으면 지나감
        if (not name) or (not weight) or (not height):
            continue

        bmi= int(weight) / (int(weight) / 100) ** 2
        result = ''
        if 25 <= bmi:
            result = '과체중'
        elif 18.5 <= bmi:
            result = '정상 체중'
        else:
            result = '저체중'

        print('\n'.join([
            '이름: {}', 
            '몸무게: {}',
            '키: {}',
            'BMI: {:.2f}',
            '결과: {}'
        ]).format(name, weight, height, bmi, result))

# N줄만 출력하려면: count를 하나씩 늘려가서 N만큼 출력되면 break 되도록 수정하면 됨!

[제너레이터]

: 함수의 코드를 조금씩 실행할 때 사용. 메모리 효율성을 위해서. 제너레이터와 이터레이터는 완전히 같지는 않지만 기본적인 단계에서는 거의 비슷하다고 봐도 무방함.

def test():
    print('A 지점 통과')
    yield 1
    print('B 지점 통과')
    yield 2
    print('C 지점 통과')

output = test()

print('D 지점 통과')
a = next(output)
print(a)

print('E 지점 통과')
b = next(output)
print(b)

print('F 지점 통과')
c = next(output)
print(c)

next(output)

# 실행 결과:
# D 지점 통과
# A 지점 통과
# 1
# E 지점 통과
# B 지점 통과
# 2
# F 지점 통과
# C 지점 통과
# ---------------------------------------------------------------------------
# StopIteration                             Traceback (most recent call last)
# ~\AppData\Local\Temp\ipykernel_21056\1173299310.py in <module>
#      17 
#      18 print('F 지점 통과')
# ---> 19 c = next(output)
#      20 print(c)
#      21 
# 
# StopIteration:

[global]

global a
a = 10

def func():
    global a 
    print(a) # 함수 내부에서 함수 외부에 있는 변수를 출력
    a = 20 # 함수 외부에 있는 번수의 값을 교체

func()
print(a)

# 실행 결과:
# 10
# 20

# global 키워드를 사용하지 않으면 'UnboundLocalError'를 발생시킴

[예외 처리]

• 예외 / 런타임 오류: 프로그램 실행 중에 발생하는 오류
• 방법
  • 조건문 사용
  • try 구문 사용

- 조건문 사용

userInputA = input('정수 입력')

if userInputA.isdigit(): # 0이상의 정수를 입력받았을 때만 작동
    numberInputA = int(userInputA)

    print('원의 반지름>>', numberInputA)
    print('원의 둘레>> {:.2f}'.format(2 * 3.14 * numberInputA))
    print('원의 넓이>> {:.2f}'.format(3.14 * numberInputA * numberInputA))
else:
    print('정수를 입력하지 않았습니다.')

# ---------------------------------------- #

- try except 구문

try:
    numberInputA = int(input('정수 입력>>'))

    print('원의 반지름>>', numberInputA)
    print('원의 둘레>> {:.2f}'.format(2 * 3.14 * numberInputA))
    print('원의 넓이>> {:.2f}'.format(3.14 * numberInputA * numberInputA))
except:
    print('무언가 잘못되었습니다')

# ---------------------------------------- #

- try except else finally 구문

- 형식:
            try:
                예외가 발생할 가능성이 있는 코드
            except:
                예외가 발생했을 때 실행할 코드
            else:
                예외가 발생하지 않았을 때 실행할 코드
            finally:
                무조건 실행할 코드

try:
  numberInputA = int(input('정수 입력>>'))

        print('원의 반지름>>', numberInputA)
      print('원의 둘레>> {:.2f}'.format(2 * 3.14 * numberInputA))
      print('원의 넓이>> {:.2f}'.format(3.14 * numberInputA * numberInputA))
except:
        print('정수를 입력하지 않았습니다!')
else:
      print('예외가 발생하지 않았습니다.')
finally:
        print('일단 프로그램이 어떻게든 끝났습니다.')

# 규칙:
# 1. try 구문은 단독으로 사용할 수 없으며, 반드시 except 구문 또는 finally 구문과 함께 사용
# 2. else 구문은 반드시 except 구문 뒤에 사용
# (즉, try else 구문은 불가능)

# finally 키워드는 굳이 없어도 되지만 코드 정리를 위해 사용한다
# try 구문 내부에서 return 키워드로 중간에서 탈출해도 finally 구문은 반드시 실행

def test():
    print('1st line of test()')
    try:
        print('try')
        return
        print('next to try')
    except:
        print('except')
    else:
        print('else')
    finally:
        print('finally')
    print('end line of test()')

test()

# 실행 결과:
# 1st line of test()
# try
# finally

[예외 고급]

#예외 객체

try:
    numberInputA = int(input('정수 입력>>'))

    print('원의 반지름>>', numberInputA)
    print('원의 둘레>> {:.2f}'.format(2 * 3.14 * numberInputA))
    print('원의 넓이>> {:.2f}'.format(3.14 * numberInputA * numberInputA))

except Exception as exception:
    print('type(exception):', type(exception))
    print('exception:', exception)

# 실행 결과:
# 정수 입력>> yes
# type(exception): <class 'ValueError'>
# exception: invalid literal for int() with base 10: 'yes'

# ---------------------------------------- #

# 예외 구분하기

listNumber = [52, 273, 32, 72, 100]

try:
    numberInput = int(input('정수 입력>>'))
    print('{}번째 요소: {}'.format(numberInput, listNumber[numberInput]))
except ValueError:
    print('정수를 입력해주세요!')
except IndexError:
    print('리스트의 인덱스를 벗어남.')

# ---------------------------------------- #

# 모든 예외 잡기

listNumber = [52, 273, 32, 72, 100]

try:
    numberInput = int(input('정수 입력>>'))
    print('{}번째 요소: {}'.format(numberInput, listNumber[numberInput]))
    예외.발생해주세요()

except ValueError as exception:
    print('정수를 입력해주세요!')
    print(type(exception), excpetion)
except IndexError as exception:
    print('리스트의 인덱스를 벗어남.')
    print(type(exception), excpetion)
except Exception as exception:
    print('미리 파악하지 못한 예외가 발생했습니다.')
    print(type(exception), exception)

Date::Date(string s) {
 int index = s.find('/');
 year = stoi(s.substr(0, index));
 s = s.substr(index + 1);
 index = s.find('/');
 month= stoi(s.substr(0, index));
 s = s.substr(index + 1);
 day = stoi(s);
}

• cstdlib ctime 포함시키기
• srand((unsigned)time(0)); 으로 시드 초기화
• rand() 로 난수 생성
• a~b사이: rand() % (b - a + 1) + a

  #include <iostream>
  #include <cstdlib>
  #include <ctime>
  using namespace std;
  

class Random { public: Random(); int next(); int nextInRange(int, int); }; Random::Random() { srand((unsigned)time(0)); } //시드 초기화 int Random::next() { return rand(); } //032767 사이의 난수 int Random::nextInRange(int a, int b) { return rand() % (b - a + 1) + a; } //ab 사이의 난수 int main() { //난수 10개 생성 Random r;

for (int i = 0; i < 10; i++) {
    cout << r.next() << ' ';
}
cout << endl;
for (int i = 0; i < 10; i++) {
    cout << r.nextInRange(2, 4) << ' ';
}
cout << endl;

}

3. 챕터 4의 실습문제 3(2): find 함수 사용하기
```cpp
#include <iostream>
#include <string>
using namespace std;

int main() {

    string str;
    int count = 0;
    cout << "문자열 입력>>";
    getline(cin, str);
    int found = str.find('a');
    while (found != -1) {
        count++;
        found = str.find('a', found + 1);
    }

    cout << "문자 a는 " << count << "개 있습니다." << endl;

    return 0;
}

A.순환

• 순환: O(logn) | 함수 호출 오버헤드
• 반복: O(n) | for/while을 이용해 수행속도가 빠르지만 순환적인 문제에서 프로그램 작성이 복잡함
• 순환 -> 반복 가능

  피보나치 수열 : 순환호출이 비효율적임 <- 같은 항 중복 계산

    int fib(int n){
        if(n == 0) return 0;
        if(n == 1) return 1;
        return (fib(n-1) + fib(n-2));
    }

  B.트리 - 이진트리

• 차수: 노드의 자식 노드의 개수

1. n개의 노드를 가진 트리는 n-1개의 간선을 가짐
2. 높이가 h: 최소 h개, 최대 2^h-1개의 노드를 가짐
3. n개의 노드를 가진 트리의 최대 높이는 n, 최소 높이는 |log(n+1)|

>    bool isLeaf() { return left == NULL 
                        && right == NULL; }

• 이진트리의 기본 순회 a) 전위(preorder): 루트 - 왼쪽 - 오른쪽 (VLR) b) 중위(inorder): 왼쪽 - 루트 - 오른쪽 (LVR) c) 후위(postorder): 왼쪽 - 오른쪽 - 루트 (LRV)

    [예시]: inorder
    void inorder(BinaryNode* node{
        if(node != NULL){
            if(node->getLeft() != NULL){
                inorder(node->getLeft());
            }
  
            printf(" [%c] ", node->getData());
  
            if(node->getRight() != NULL){
                inorder(node->getRight());
            }
        }
    }
  
    [예시]: levelorder - '큐' 사용
    void levelorder(){
        if(!isEmpty()){
            CircularQueue q;
            q.enqueue(root);
            while(!q.isEmpty()){
                BinaryNode* n = q.dequeue();
                if(n != NULL){
                    printf(" [%c] ", n->getData());
                    q.enqueue(n->getLeft());
                    q.enqueue(n->getRight());
                }
            }
        }
        printf("\n");
       }

  

• 노드 개수 계산 - getCount()함수

    int getCount(){ return isEmpty() ? 0 : getCount(root); }
    int getCount(BinaryNode* node){
        if(node == NULL) return 0;
  
        return 1 + getCount(node->getLeft())
                 + getCount(node->getRight());
    }

• 단말 노드 개수 계산 - getLeafCount()함수

    int getLeafCount(){ return isEmpty() ? 0 : getLeafCount(root); }
    int getLeafCount(){
        if(node == NULL) return 0;
  
        if(node->isLeaf()) retrun 1;
  
        else return getLeafCount(node->getLeft())
                    + getLeafCount(node->getRight());
    }

• 트리 높이: 서브트리 높이 + 1

    int getHeight(){ return isEmpty() ? 0 : getHeight(root); }
    int getHeight(BinaryNode* node){
        if(node == NULL) return 0;
  
        int hLeft = getHeight(node->getLeft());
        int hRight = getHeight(node->getRight());
  
        return (hLeft > hRight) ? hLeft + 1 : hRight + 1;
    }
  
    +) hLeft == hRight인 경우: root 노드만 있을 때

• 수식트리의 계산

    int evaluate() { return evaluate(root); }
    int evaluate(BinaryNode* node){
        if(node == NULL) return 0;
        else{
            int op1 = evaluate(node->getLeft());
            int op2 = evaluate(node->getRight());
            switch(node->getData){
                ...
            }
            return 0;
        }
    }

• 폴더 용량 계산: 후위 순회

    int calcSize(BinaryNode* node){
        if(node == NULL) return 0;
  
        return node->getData()
                + calcSize(node->getLeft())
                + calcSize(node->getRight());
    }

  c. 이진 탐색 트리

• 왼쪽서브트리key <= 루트key <= 오른쪽서브트리key

• 중위 순회 -> 오름차순으로 정렬

• 탐색 연산 a) 키값이 루트와 같으면: 탐색 끝! b) 키값이 루트보다 작으면: 왼쪽 자식 기준으로 재탐색 c) 키값이 루트보다 크면: 오른쪽 자식 기준으로 재탐색

    [반복으로 구현한 탐색 함수]
    BinaryNode* searchlter(BinaryNode* n, int key){
        while(n != NULL){
            if(key == n->getData()) return n;
            else if(key < n->getData()) n = n->getLeft();
            else n = n->getRight();
        }
        return NULL;
    }
  
    [순환으로 구현한 탐색 함수]
    void insertRecur(BinaryNode* r, BinaryNode* n){
        if(n->getData() == r->getData()) return;
        elseif(n->getData() < r->getData()){
            if(r->getLeft() == NULL) r->setLeft(n);
            else insertRecur(r->getLeft(), n);
        }
        else{
            if(r->getRight() == NULL) r->setRight(n);
            else insertRecur(r->getRight(), n));
        ]
    }
  
    [삭제함수에서...] 
    삭제하려는 노드가 왼쪽 또는 오른쪽 자식만 가진 경우 
    -> 부모 노드의 자식으로 자식노드의 자식을 직접 연결
        if(node == root) root = child;

• 성능 분석 a) 최선: h = logn | O(logn) b) 최악: h = n | O(n)

[영어사전]

• 오름차순(inorder)으로 출력

    int compare(Record* n) { return compare(n->word); }
    int compare(char* w) { return strcmp(w, word) }

• 탐색/삽입에서

    ...
    if(n->compare(r) == 0) return;
    else if(n->compare(r) > 0)
    ...

• 삭제에서

    ...
    while(node != NULL && node->compare(data) != 0){
        parent = node;
        node = (node->compare(data) < 0) ? 
                node->getleft() : node->getright();
   ...

  D. 우선순위 큐 - 힙

  a) 완전이진트리의 일종 b) 우선순위 큐를 위해 만들어진 자료구조 c) 일종의 '반 정렬 상태' 유지 d) 삽입/삭제 모두 최악의 경우에 O(logn) e) 최대 힙: 부모노드키값 >= 자식노드키값

      최소 힙: 부모노드키값 <= 자식노드키값
   f) n개의 노드를 가지고 있는 힙의 높이는 O(logn)

  g) 전체 정렬 보다는 가장 큰 값 몇게만 필요할 때 유용함
• 삽입 -> Upheap

    ...
    while(i != 1 && key->getParent.getKey()){
        node[i] = getParent(i);
        i /= 2;
    }
    ...

• 삭제: 항상 루트(가장 큰 값을 가진 노드)가 삭제됨! -> Downheap

    ...
    if(child < size &&
            getLeft(parent).getKey() < getright(parent).getKey())
        child++;                    //큰 값을 오른쪽 자식이 갖고 있음
       if(last.getKey() >= node[child].getKey()) 
        break;
    ...
  

- 힙 정렬
```cpp
    void heapSort(int a[], int n){
        MaxHeap h;
        ...
        //최대힙에서는 삭제시 가장 큰 값이 반환되므로
        //오름차순으로 정렬하기 위해서
        //삭제 항목을 배열의 끝부터 앞으로 채워나감
        for(int i = n-1; i >= 0; i--)
            a[i] = h.remove()->getKey();
    }

E. 그래프

• 오일러 정리: 모든 정점에 연결된 간선의 수가 짝수이면 오일러 경로 존재함.

• 완전 그래프의 간선 수: (n x (n-1)) / 2

  1. 인접 행렬(adjacency matrix)

    void insertVertex(char name){
        if(!isFull()) vertices[size++] = name;
        else printf("Error: 그래프 정점 개수 초과!\n");
    }
    void insertEdge(int u, int v){
        setEdge(u,v,1);
        setEdge(v,u,1);
    }
    void display(FILE* fp = stdout){
        ...
       }

• DFS 구현

    class SrchAMGraph : public AdjMatGraph{
    protected:
        bool visited[MAX_VTXS];
    public:
        void resetVisited(){
            for(int i = 0; i < size; i++)
                visited[i] = false;
        }
        bool isLinked(int u, int v){ return getEdge(u, v) != 0; }
        void DFS(int v){
            fisited[v] = true;
            printf("%c ", getVertex(v));
            for(int w = 0; w < size; w++)
                if(isLinked(v, w) && visited[w] == false)
                    DFS(w);
        }
    }

• BFS 구현

    #include "AdjListGraph.h"
    #include "CircularQueue.h"
    ...
    void BFS(int v){
        visited[v] = true;
        printf("%c ", getVertex(v));
  
        CircularQueue que;
        que.enqueue(v);
        while(!que.isEmpty()){
            int v = que.dequeue();
            for(int w = 0; w < size; w++)
                if(isLinked(v, w) && visited[w] == false){
                    visited[w] = true;
                    printf("%c ", getVertex(w));
                    que,enqueue(w);
                }
        }
    }

  2. 인접 리스트 -> X

  F. 탐색

  G. AVL 트리

  a) 스스로 노드를 재배치하여 균형 상태 유지 b) 평균/최선/최악: O(logn) c) 탐색 연산: 이진탐색트리와 동일 d) 삽입/삭제 연산: 균형상태가 깨질 수 있음

    -> 불균형 상태로 변한 가장 가까운 조상 노드의 
       서브 트리들에 대해 다시 균형을 맞춤

• 균형 인수(bf, balance factor) : = 왼쪽 서브트리 높이 - 오른쪽 서브트리 높이 : 모든 노드의 균형 인수가 -1 ~ 1 이면 AVL 트리

  >> LL타입

  : 가장 가까우면서 균형 인수가 ±2인 조상노드의 왼쪽 서브트리(L)의 왼쪽서브트리(L)에 삽입

• LL회전(= 오른쪽 회전) : a) B의 오른쪽 자식을 A의 왼쪽 자식으로 만든다 : b) A를 B의 오른쪽 자식의 노드로 만든다

     BinaryNode* reBalance(BinaryNode* parent){
         int hDiff = getHeightDiff(parent);
         if(hDiff > 1){
         if(getHeightDiff(parent->getLeft()) > 0)
             parent = rotateLL(parent);
         else parent = rotateLR(parent);
         ...
     }
  
     BinaryNode* rotateLL(BinaryNode* parent){
         BinaryNode* child = parent->getLeft();
         parent->setLeft(child->getRight());
         child->setRight(parent);
         return child;
     }
  
     Void insert(int data){
         if(isEmpty()) root = new BinaryNode(data);
         else root = insertAVL(root, data);
     }
  
     BinaryNode* insertAVL(BinaryNode* parent, int data){
         if(data < parent->getData()){
             if(parent->getLeft() != NULL)
                 parent->setLeft(insertAVL(parent->getLeft(),data));
             else parent->setLeft(new BinaryNode(data));
             return reBalance(parent);
         }
         else if(data > parent->getData()){
             if(parent->getRight() != NULL)
                 parent->setRight(insertAVL(parent->getRight(), data));
             else parent->setRight(new BinaryNode(data));
             return reBalance(parent);
         }
         else{ printf("중복 키 에러!\n"); return NULL; }
     }

  H. 해싱

• 이상적인 해싱 함수: O(1)

• 좋은 해시 함수의 조건 a) 충돌이 적어야 함 b) 함수 값이 테이블의 주소 영역 내에 고르게 분포 c) 계산이 빨라야 함

• 구조적 문제 해결법 a) 선형 조사법 b) 이차 조사법

   c) 체이닝

테이블은 행과 열로 구성된 2차원 데이터 구조입니다. 각 행은 레코드 또는 엔트리라고 불리며, 각 열은 해당 레코드의 특정 속성을 나타냅니다. 예를 들어, 고객 정보를 포함하는 테이블은 각 행이 개별 고객을 나타내고, 각 열은 이름, 주소, 전화번호 등과 같은 특정 고객 속성을 포함합니다. 테이블은 일반적으로 데이터베이스에서 사용되며, 데이터를 구조화하고 검색 및 관리하기 위해 사용됩니다.

반면에 그리드는 행과 열이 규칙적으로 배치된 2차원 그래픽 형식입니다. 그리드는 주로 데이터를 시각적으로 표현하는 데 사용됩니다. 예를 들어, 스케줄을 나타내는 그리드는 행이 시간대를 나타내고 열이 요일을 나타내며, 각 셀은 해당 시간대와 요일에 예정된 일정을 표시합니다. 그리드는 주로 스프레드시트 프로그램이나 데이터 시각화 도구에서 사용되며, 데이터의 시각적 표현과 분석에 유용합니다.

요약하면, 테이블은 데이터를 구조화하고 조직화하는 데 사용되는 2차원 데이터 형식이며, 그리드는 데이터를 시각적으로 표현하고 분석하는 데 사용되는 2차원 그래픽 형식입니다.

(by 챗GPT)

테이블은 정적이지만 그리드는 동적 연결리스트인데 그리드를 고정하는 방법도 있어서 요즘에는 굳이 테이블 쓰지 않음. (by 챗tahnPT)

예시)

    String[] numbers = {"one", "two", "three"};
    for(int i=0; i<numbers.length; i++) {
        System.out.println(numbers[i]);
    }

    를 for-each 문으로 바꾸면

    String[] numbers = {"one", "two", "three"};
    for(String number: numbers) {
        System.out.println(number);
    }

    출력 결과는 똑같다.

    one
    two
    three

출처: 점프 투 자바

#include <iostream>

class MyClass {
public:
    int myVariable;
    int myFunction() {
        return myVariable;
        // 멤버 함수의 구현
    }
};

int main() {
    MyClass object;
    MyClass* pointer = &object;

    object.myVariable = 10;
    // 도트 연산자로 멤버 변수에 접근
    std::cout << object.myFunction();
    // 도트 연산자로 멤버 함수 호출

    printf("\n");

    pointer->myVariable = 20;
    // 화살표 연산자로 포인터를 통해 멤버 변수에 접근
    std::cout << pointer->myFunction();
    // 화살표 연산자로 포인터를 통해 멤버 함수 호출

    return 0;
}

[실행결과]
10
20

출처: 코딩뚠뚠 [출처: ChatGPT]

1. Vector<E> 클래스

2. ArrayList<E> 클래스

3. Iterator<E> 인터페이스

[사용법]
    Vector<Integer> v = new Vector<Integer>();
    Iterator<Integer> it = v.iterator();
    while(it.hasNext()) { // 모든 요소 방문 
    int n = it.next(); // 다음 요소 리턴 ...}

4. HashMap<K,V> 클래스

• HashMap은 Key와 Value의 쌍으로 구성되어있고 put()하는 값이 순서대로 저장되지 않기 때문에 출력 역시 입력한 순서대로 되지 않는다.

5. LinkedList<E> 클래스

6. Collection 클래스

: 모든메소드는 static 타입이므로 Collection 객체를 생성할 필요가 없다.

• sort() : 요소를 오름차순으로 정렬
• reverse() : 요소를 내림차순으로 정렬
• max(), min() : 요소들의 최댓값과 최솟값 찾아내기
• binarySearch() : 이진 검색

  [사용예시]
    Collections.sort(myList);
    int index = Collections.binarySearch(myList, "A");

[참고] Vector와 ArrayList는 거의 동일한 컬랙션 클래스지만,

• ArrayList의 단점: 스레드 간에 동기화를 지원하지 않기 때문에, 다수의 스레드가 동시에 ArrayList에 요소를 삽입하거나 삭제할 때 ArrayList의 데이터가 훼손될 우려가 있음.
• ArrayList의 장점: 멀티스레드 동기화를 위한 시간 소모가 없기 때문에, Vector보다 속도가 빨라 단일 스레드 응용에는 더 효과적임.

출처: 명품 JAVA 출처: GeeksForGeeks

& (참조)

: 주소값 반환

#include<iostream>
int main(){
    int a1 = 3;
    int &a2 = a1; 
    // a1를 참조하는 a2
    // a1과 a2는 같은 주소를 갖는다. 
    a2 = 5;
    // 그래서 a2를 수정하면 a1도 바뀜!
    printf("a1 = %d\n", a1);
    printf("a2 = %d\n", a2);
    return 0;
[출력결과]
    a1 = 5
    a2 = 5
}

[조건]

• 상수를 참조할 수 없음. ( int &num = 2; )
• 참조하는 값이 없는 경우 선언 불가. ( int # )
• NULL값 참조 불가. ( int &num = NULL; )

* (포인터)

1. 포인터 변수 선언 (형식: 형* 포인터이름)
2. 포인터가 가리키는 주소의 '값' (형식: *포인터 이름)

    [예시]
    int* ptr1; == int형 변수를 가리킬 수 있는 ptr1
    *ptr2 == ptr2가 가리키고 있는 주소에 있는 값

출처: 하루 세번 출처: Jo.log 출처: ITstory

: 익명 함수를 정의할 수 있는 기능.

• 형식 : 개시자 + 인자 + 반환 타입 + 함수의 몸통
• 다른 함수나 객체의 인자로 전달되거나 반환되는 함수 객체를 생성하는 데 사용.
• 함수 객체로 구현할 경우 번거롭게 구조체를 먼저 정의해서 사용할 필요가 없기 때문에 간단하게 표현이 가능하다. ```cpp // 개시자 없음, 인자 없음, 리턴 타입 없음. #include int main() { { std::cout << "Hello lambda!" << std::endl; }(); return 0; }
• // 개시자 없음, 리턴 타입 없음. #include int main() { [](std::string name) {

     std::cout << "My name is " << name << std::endl;

  }("Dangdang"); return 0; }
• // std::function에 대입 가능. #include #include int main() { // std::function<void (std::string)> auto introduce = [](std::string name) {

     std::cout << "My name is " << name << std::endl;

  }; introduce("Jinsoo Heo"); return 0; }

### **2. Predicate**        >> 몰루입니다ㅠ
: 조건자. true/false 또는 int를 리턴하는 함수.
### **3. Array vs Pointer**
- array의 배열 변수가 보유한 주소는 배열의 첫번째 요소의 주소.
- arr = 배열의 시작 원소를 가리킴
- &arr = 배열 자체를 가리키는 포인터
```cpp
    #include <iostream>
    using namespace std;
    void foo(int* arr){
        cout << sizeof(arr);
    }
    int main(){
        int arr[3] = { 1, 2, 3 };
        cout << sizeof(arr);
        foo(arr);
        return 0;
    }
    [출력 결과]: 12 4

4. Pointer vs Reference

: 이미 정리함

5. Smart Pointer

: 포인터처럼 동작하는 클래스 템플릿. new 키워드가 반환하는 주소값을 대입하면, 따로 메모리를 해제할 필요가 없음. (사용이 끝난 메모리를 자동으로 해제해줌!)

a. unique_ptr : ** 하나의 스마트 포인터만이 특정 객체를 소유할 수 있도록, 객체에 **소유권 개념을 도입한 스마트 포인터.

• 해당 객체의 소유권을 가지고 있을 때만, 소멸자가 해당 객체를 삭제할 수 있음.
• move() 멤버 함수를 통해 소유권을 이전할 수는 있지만, 복사할 수는 없음.
• 소유권이 이전되면, 이전 unique_ptr 인스턴스는 더는 해당 객체를 소유하지 않게 재설정됨.

    unique_ptr<int> ptr01(new int(5));
    // int형 unique_ptr 선언
    auto ptr02 = move(ptr01);
    // ptr01에서 ptr02로 소유권 이전
    ptr02.reset();    
    // ptr02가 가리키고 있는 메모리 영역을 삭제
    ptr01.reset();    
    // ptr01가 가리키고 있는 메모리 영역을 삭제

*b. shared_ptr : * 하나의 특정 객체를 참조하는 스마트 포인터가 총 몇 개인지를 참조하는 스마트 포인터.

• 참조 횟수는 특정 객체에 새로운 shared_ptr이 추가될 때마다 1씩 증가하며, 수명이 다할 때마다 1씩 감소함.

• use_count() : shared_ptr 객체가 현재 가리키고 있는 리소스를 참조 중인 소유자의 수를 반환

• make_shared(): shared_ptr 인스턴스를 안전하게 생성

    shared_ptr<Person> a = make_shared<Person>("A", 30);
    cout << a.use_count() << endl;
    auto b = a;
    cout << a.use_count() << endl
    b.reset(); // shared_ptr인 b를 해제함.
    cout << a.use_count() << endl; 
    [출력 결과]
    1
    2
    1

• c. weak_ptr: * 하나 이상의 shared_ptr 인스턴스가 소유하는 객체에 대한 접근을 제공하지만, 소유자의 수에는 포함되지 않는 스마트 포인터.

• 서로 상대방을 가리키는 shared_ptr 인스턴스 사이의 순환 참조를 제거하기 위해 사용.

  6. lvalue vs rvalue

  a. lvalue : 단일 표현식 이후에도 사라지지않고 지속되는 객체. b. rvalue : 표현식이 종료된이후에는 더이상 존재하지 않는 임시적인 값.

    [예시]
    a = b + c; 에서
    "a"는 lvalue, "b + c"는 rvalue

  7. Char vs std::string

  a. char : 문자. ASCII 코드로 해석되는 1byte의 정수. b. std::string : ""를 이용해 표현되는 문자열 상수. (이름을 가지고 있지 않으며 문자열의 내용 또한 변경할 수 없기 때문.)

  8. Literal constant

  : '상수'. 코드에 직접 삽입된 값. 변경할 수 없음.

• 숫자 리터럴에서는 유형을 결정하는 접미사가 포함될 수 있고 선택사항으로 생략하면 컴파일러는 의도하는 것이 어떤 종류의 상수인지 유추함.

• 문자와 문자열 리터럴도 있음.

  9. Function Overloading

  : 다른 매개 변수를 가진 같은 이름의 여러 함수를 만듦.

    void Display(const char* str, int n){
        for (int i = 0; i < n; i++){
            printf(str);
        }
    }
    void Display(const char* str1, const char* str2){
        printf(str1 + str2);
    }
    void Display(int x, int y){
        printf(x * y);
    }
    void Display(double x, double y){
        printf(x / y);
    }
    // 여기서 Display(4.2, 3); 을 하면
    // 함수가 두개 호출 가능해 컴파일 오류 발생.

  10. Operator Overloading

  : 기존에 제공하고 있는 연산자를 전역 함수 또는 클래스로 재정의하여 사용자 정의해 사용하는 것.

• 새로운 연산자를 정의할 수 없음.

• 기본 제공 데이터 형식에 적용할 때 연산자의 의미를 다시 정의할 수 없음.

• 오버로드 된 연산자는 non-static 클래스 멤버 함수거나 전역 함수여야 함.

• 단항 연산자 또는 이항 연산자(&, *, +, -)로 오버로드 가능하며 각 사용을 별도로 오버로드 할 수 있음.

• 멤버함수로 오버로드된 연산자의 첫번째 파라미터는 항상 연산자가 호출되는 객체의 클래스 형식.

• 오버로드 할 수 없는 연산자: . .* :: ?: # ##

    #include <iostream>
    using namespace std;
    class Point{
    private:
        int x, y;
    public:
        Point(int x_, int y_){
            x = x_;
            y = y_;
        }
        void print(){
            cout << "x : " << x << ", y : " << y << "\n";
        }
        Point operator + (Point& p){
            x = x + p.x;
            y = y + p.y;
            return Point(x, y);
        }
    };
  
    int main(){
        Point p1 = { 1, 1 };
        Point p2(2, 2);
  
        Point p3 = p1 + p2;
  
        p3.print();
        return 0;
    }
  
    [출력 결과]
    x: 3, y: 3

  11. Constructor, Copy constructor

• a. 생성자 :* 해당 클래스의 객체가 인스턴스화될 때 자동으로 호출되는 특수한 종류의 멤버 함수.

• 일반적으로 클래스의 멤버 변수를 적절한 기본값 또는 사용자 제공 값으로 초기화하거나 클래스를 사용하는 데 필요한 설정(ex. 파일 열기 등)이 필요한 경우 사용.

• 생성자 이름은 클래스와 이름이 같아야함.

• 생성자는 리턴타입이 없다. (void도 X)

b. 복사 생성자 : 객체의 복사본을 생성할 때 호출되는 생성자.

• 자신과 같은 클래스 타입의 다른 객체에 대한 참조를 인수로 전달받아, 그 참조를 가지고 자신을 초기화 하는 방법.

• 새롭게 생성되는 객체가 원본 객체와 같으면서도 완전한 독립성을 갖게 함. (복사 생성자를 이용한 대입은 깊은복사이기 때문!) c. 복사 대입 연산자 : 같은 타입의 객체를 이미 생성되어 이쓴 객체에 값을 복사할 때 사용.

• 객체가 함수에 인수로 전달될 때

• 함수가 객체를 반환값으로 반환할 때

• 새로운 객체를 같은 클래스 타입의 기존 객체와 똑같이 초기화 할 때

        #include <iostream>
  
    using namespace std;
  
    class Person{
    public:
        int age;
        char* name;
        Person(int _age, const char* _name){
            age = _age;
            name = new char[strlen(_name) + 1];
            strcpy(name, _name);
        }
  
      Person(const Person& p){ //복사 생성자로 깊은 복사하기
               age = p.age;
            name = new char[strlen(p.name) + 1];
               strcpy(name, p.name);
        }
  
        void infoPerson(){
            cout << "이름: " << name << endl;
            cout << "나이: " << age << endl;
        }
    };
  
    void main(){
        Person A(20, "홍길동");
        Person B = A;
  
           B.age = 30;
        strcpy(B.name, "이순신");
  
        A.infoPerson();
        B.infoPerson();
    }
    [출력 결과]
    이름: 홍길동
    나이: 20
    이름: 이순신
    나이: 30
  

[참고: 얕은 복사 & 깊은 복사](https://velog.io/@meer_/%EC%96%95%EC%9D%80-%EB%AC%BC-%EA%B9%8A%EC%9D%80-%EB%AC%BC)
### **12. Abstract class**
a. 순수 가상 함수 : 파생 클래스에서 재정의할 것으로 기대하는, '반드시 재정의 되어야만 하는' 멤버 함수.
- 형식: virtual 멤버함수원형 = 0;
```cpp
    예시: virtual void foo() = 0;

b. 추상 클래스 : 하나 이상의 순수 가상 함수를 포함하는 클래스.

• 반드시 사용되어야 하는 멤버 함수를 추상 클래스에 순수 가상 함수로 선언해 놓으면, 이 클래스로부터 파생된 모든 클래스에서는 이 가상 함수를 반드시 재정의해야 함.

• 동작이 정의되지 않은 순수 가상 함수를 포함하고 있으므로, 인스턴스 생성 X.

    class Animal{
    public:
        virtual ~Animal(){}        // 가상 소멸자 선언
        virtual void Cry() = 0;    //순수 가상 함수 선언
    class Dog : public Animal{
    public:
        virtual void Cry(){ cout << "멍멍!" << endl; }
    }
    class Cat : public Animal{
    public:
        virtual void Cry(){ cout << "야옹!" << endl; }
    }
    int main(){
        Dog myDog;
        myDog.Cry();
        Cat myCat;
        myCat.Cry();
        return 0;
    }
    [출력 결과]
    멍멍!
    야옹!
    /*
    Animal 클래스를 상속받는 파생 클래스인
    Dog 클래스와 Cat 클래스는
    Cry() 함수를 오버라이딩해야만
    인스턴스를 생성할 수 있음
    */

  13. Inheritance

  : 상속.

    [형식]
    class 자식클래스이름 : 접근제한자 부모클래스이름 {...}

  a. private 상속

    #include <iostream>
    using namespace std;
  
    class A {
    private:
        int a;
    protected:
        int b;
    public:
        int c;
    };
  
    class B : private A { 
    //b,c맴버 변수는 private 맴버로 접근 범위 졻혀짐
    };
  
  

int main() {
    B b;
    //a = private, b = private, c = private
    b.a;
    b.b;
    b.c;
}

b. protected 상속
```cpp
    #include <iostream>
    using namespace std;

    class A {
    private:
        int a;
    protected:
        int b;
    public:
        int c;
    };

    class B : protected A { 
    //c맴버 변수는 protected 맴버로 접근 범위 졻혀짐
    };


    int main() {
        B b;
        //a = private, b = protected, c = protected
        b.a;
        b.b;
        b.c;
    }

c. public 상속

    #include <iostream>
    using namespace std;

    class A {
    private:
        int a;
    protected:
        int b;
    public:
        int c;
    };

    class B : public A {
    //맴버 변수의 접근 제한에 변화없음
    };


    int main() {
        B b;
        //a = private, b = protected, c = public
        b.a;
        b.b;
        b.c;
    }

14. virtual function

: 가상함수를 선언할 때 사용하는 키워드.

    [형식]
    virtual 반환형 함수이름();

• 가상함수로 선언하면 동적 바인딩이 되어서 포인터의 타입이 아닌 포인터가 가리키는 객체의 타입에 따라 멤버 함수를 선택하게 됨.
• 클래스의 public 섹션에 선언.
• static 또는 friend 불가.
• 기본 클래스의 포인터 또는 참조를 통해 access 해야함.
• 반환형과 매개변수는 기본 클래스와 파생 클래스에서 동일.
• override 시에는 virtual 키워드를 붙여도 되고 안붙여도 됨.
• 가상 소멸자를 가질 수 있지만 가상 생성자를 가질 수 없음.

15. override

: 상속받았을 때 부모 클래스의 함수를 사용하지 않고 다른 기능을 사용할 때 함수를 자식 클래스에서 같은 이름, 같은 매개변수로 재정의해서 사용하는 것. cf) 오버로딩: 함수 중복 정의- 같은 이름의 함수에 매개변수를 다르게 사용해 매개변수에 따라 다른 함수가 실행되는 것.

• 오버라이드 하고자 하는 메소드가 상위 클래스에 존재해야 함.

• 메소드 이름이 같아야함.

• 파라미터 개수와 자료형이 같아야함.

• 리턴형이 같아야함.

• 상위 메소드와 동일하거나 내용이 추가 되어야 함.

  16. Polymorphism

  : 다형성(여러가지 형태를 갖는 성질).

• 함수의 기능적 다형성과 상속에 의해 만들어진 계층 관계를 활용하는 기술

• 상속구조를 가지고 있는 경우 상위 클래스의 포인터나 참조자로 하위 클래스의 기능과 자료를 사용할 수 있다.

• 상위 클래스에 가상 멤버 변수가 하나 이상 있어야함.

• 하위 클래스에서 오버라이딩 할 멤버 함수가 없다면 상위 클래스의 소멸자를 가상함수로 만들고 객체는 상위 클래스의 포인터나 참조자로 만들어야함. a. 가상 함수 : 부모 클래스와 자식 클래스에 동일한 이름의 함수의 다른 작동 b. 함수 템플릿 : 동일한 이름의 함수가 다양한 자료형을 처리 c. 함수 오버로드 : 동일한 이름의 함수가 다른 작동 d. 연산자 오버로드 : 한가지 연산자가 다양한 작동

  17. up-casting, down-casting

• a. up-casting* : 파생 클래스의 객체를 기본 클래스의 포인터로 가리키는 것.

     예시:
         Pizza cheesePizza;
         Pizza* pp = &cheesePizza;
         Circle cc = pp;    // 업캐스팅

• b. down-casting* : 기본 클래스 포인터가 가리키는 객체를 파생 클래스의 포인터로 가리키는 것. 업캐스팅에서 다시 원래 형으로 되돌려주는 작업. 업캐스팅과 달리 '명시적 타입 변환'을 지정해야 함.

     예시:
         pp = (Pizza*) cc;

  18. Template

     [형식]
     template <typename 이름>

• 컴파일러가 인자값으로 들어가는 자료형을 보고 타입을 유추하여 유연하게 함수에 적용

• a. Class Template*

     #include <iostream>
     using namespace std;
     template <typename T>
  
     T add(T x, T y) {
         return x + y;
     }
     int main()
     {
         int num1 = 10, num2 = 20;
         cout << add(num1, num2) << endl;
  
         double num3 = 10.52, num4 = 20.24;
         cout << add(num3, num4) << endl;
  
         return 0;
     }

• b. Function Template*

     #include <iostream>
     using namespace std;
     template <class T>
     //template <typename T> 와 같은 표현
     class Calcu
     {
     private:
         T num1;
         T num2;
     public:
         Calcu(T num1, T num2) {
             this->num1 = num1;
             this->num2 = num2;
         }
         T GetAdd() {
             return num1 + num2;
         }
     };
     int main()
     {
         Calcu<int> calcu1(10, 20);
         cout << calcu1.GetAdd() << endl;
  
         Calcu<double> calcu2(10.52, 20.24);
         cout << calcu2.GetAdd() << endl;
     }

• c. variadic functions* : 가변 길이 템플릿

     #include <iostream>
  
     template <typename T>
     void print(T arg) {
       std::cout << arg << std::endl;
     }
  
     template <typename T, typename... Types>
     void print(T arg, Types... args) {
       std::cout << arg << ", ";
       print(args...);
     }
  
     int main() {
       print(1, 3.1, "abc");
       print(1, 2, 3, 4, 5, 6, 7);
     }

  19. Exception

• a. try-catch / throw* >> JAVA로 정리했었다!

• b. std::exception*

     #include <exception> 해야함

• logic_error invalid_argument domain_error length_error out_of_range future_error(C++11)

• runtime_error range_error overflow_error underflow_error regex_error(C++11) system_error(C++11)

    ios_base::failure(C++11)

• bad_typeid

• bad_weak_ptr(C++11)

• bad_function_call(C++11)

• bad_alloc bad_array_new_length(C++11)

• bad_exception

• ios_base::failure(until C++11)

[출처]

람다 - 모두코드 람다 - devkoriel 조건자 - Maple story 배열과 포인터 - 소년코딩 배열과 포인터 - kangworld 스마트 포인터 - TCP school Lvalue & Rvalue - 별이 빛나는 세상 문자 - 소년코딩 문자열 - 달려라 승이 리터럴 - 소년코딩 함수 오버로딩 - TCP school 연산자 오버로딩 - 열코 생성자 - 소년코딩 복사 생성자 - TCP school 복사 생성자 - 코딩 팩토리 추상 클래스 - TCP school 추상 클래스 - HwanShell 상속 - 끝나지 않는 프로그래밍 일기 상속 - reakwon 가상 클래스 - 열코 가상 클래스 - 코딩 팩토리 오버라이드 - Insert Brain Here 다형성 - C++이야기 다형성 - 꽈이의 게임개발 lesslate 템플릿 - 코딩 팩토리 가변 길이 템플릿 - 모두의 코드 exception - 평생 공부 exception - C++ 이야기

[Call by Value]

: 값에 의한 호출. 복사해 처리하므로 원래의 값이 보존됨.

[Call by Reference]

: 함수에서 값이 아닌 주솟값을 전달하는 방식. 복사하지 않고 직접 참조. 원래 값이 영향을 받음. (C언어에서는 call by address라고 함.) 값을 전부 복사할 필요가 없으므로 자원 낭비를 확실히 줄일 수 있다.

[c언어에서]
#include <stdio.h>

void swap1 (int a, int b){
    int temp;

    temp = a;
    a = b;
    b = temp;
}
void swap2 (int* a, int* b){
    int temp;

    temp = *a;
    *a = *b;
    *b = temp;
}
int main(){
    int a, b, c, d;
    a = 10;
    b = 20;
    c = 10;
    d = 20;
    printf("%d, %d, %d, %d", a, b, c, d);

    swap (a, b);    // 내부적으로 데이터가 처리되지만 a와 b에게 전달 X!
    swap (&c, &d);    // 함수 내부에서 주소를 바꿔버려서 c와 d 자체가 교체됨!

    printf("%d, %d, %d, %d", a, b, c, d);

    return 0;
}

[출력결과]
10, 20, 10, 20
10, 20, 20, 10

빅오 크기 비교:

1 < logn < n < nlogn < n^2 < n^3 < n^k < 2^n < n!

[예시1]
int algorithm(int n){
    int k = 0;
    while (n > 1){
        n = n/2;
        k++;
    }
    return k;
}
[결과] O(logn)
-
[예시2]
sub함수의 시간복잡도가 O(n)일때
for(i = 1; i < n; i *= 2)
    sub();
의 시간복잡도는?
[답] O(nlogn)

A. 스택

: LIFO (후입선출)

// 오류 처리 함수
inline void error(char *message){
    printf("%s\n", message);
    exit(1);
}

bool isEmpty(){ return top == -1 }
bool isFull(){ return top == MAX_STACK_SIZE-1; }

void push (int e){
    if (isFull()) error("스택 포화 에러");
    data[++top] = e;
}

int pop(){
    if (isEmpty()) error("스택 공백 에러");
    return data[top--];

int peek(){
    if (isEmpty()) error("스택 공백 에러");
    return data[top];

[괄호검사 프로그램]

FILE *fp = fopen(filename, "r");
if(fp == NULL) error("Error!\n");

while ((ch = getc(fp)) != EOF{...}

1. 중위표기 수식 -> 후위표기 수식 변환
   • 연산자(operator) 스택
2. 후위표기 수식 -> 계산
   • 피연산자(operand) 스택

[ungetc()]: 방금 읽은 문자를 입력 버퍼로 되돌려줌

else if (c >= '0' && c <= '9'){
    ungetc (c, fp);
    double val;
    fscanf (fp, "%lf", &val);
    st.push (val);
}

[ INFIX TO POSTFIX ]

• 피연산자(숫자) 만나면 그대로 출력
• 연산자(op)를 만나면 : 입력op의 우선순위가 스택op의 우선순위보다
  • 같거나 낮으면 pop하고 출력하고 입력op 스택에 push
  • 높으면 입력op를 push
• 왼쪽 괄호는 스택에 push
• 오른쪽 괄호는 스택에서 왼쪽 괄호 위에 쌓여있는 모든 연산자를 출력

int precedence (char op){
    switch (op){
        case '(': case ')': return 0;
        case '+': case '-': return 1;
        case '*': case '/': return 2;
    }
    return -1;
}

[미로 탐색]

bool isValidLoc (int r, int c){
    if (r < 0||c < 0||r >= MAZE_SIZE||c >= MAZE_SIZE)
        return 0;
    else return map[r][c] == '0' || map[r][c] == 'x';

B. 큐

: FIFO (선입선출)

• 선형 큐의 문제점: 삽입을 위해서는 O(n)의 시간이 걸림
• 원형큐: 공백/포화 상태 구별을 위해 한칸을 비워둔다
  • 공백상태: front == rear
  • 포화상태: front = (rear + 1) % M

void enqueue (int val){        // 큐에 삽입
    if (isFull()) error("포화!\n");
    else{
        rear = (rear + 1) % MAX_QUEUE_SIZE;
        data[rear] = val;
    }
}

int dequeue (){        // 첫 항목을 큐에서 빼서 반환
    if (isEmpty()) error("공백!\n");
    else{
        front = (front + 1) % MAX_QUEUE_SIZE;
        return data[front];
    }
}

C. 덱

: 최근에 들어온 걸 우선순위를 주고 싶을 때

[원형덱]

class CircularDeque: Public CircularQueue{
public:
    CircularDeque() {}
    void addRear(int val){ enqueue(val); }
    int deleteFront(){ return dequeue(); }
    int getFront(){ return peek(); }

    void display(){ // CQ의 display() 재정의
        int maxi = (front < rear) ? rear: rear + MAX_Q_SIZE;
        for(int i = front + 1; i <= maxi; i++)
            printf("[%2d] ", data[i % MAX_Q_SIZE]);
    }

    int getRear(){
        if (isEmpty()) error("공백!\n");
        else return data[rear];
    }

    void addFront(int val){
        if (isFull()) error("포화!\n");
        else{
            data[front] = val;
            front = (front - 1 + MAX_Q_SIZE) % MAX_Q_SIZE;
        }
    }

    int deleteRear(){
        if (isEmpty()) error("공백!\n");
        else{
            int ret = data[rear];
            rear = (rear -1 + MAX_Q_SIZE) % MAX_Q_SIZE;
            return ret;
        }
    }
}

D. 연결 리스트

• 포인터

  • &: 변수의 주소 추출
    • *: 포인터가 가리키는 곳의 내용 추출

      [자기 참조 구조체]
      typedef struct ListNote{
      char data[10];
      struct ListNode* link;
      } Node;

• 포인터는 NULL로 초기화하자! ( int* p = NULL; )

• 연결리스트의 삽입/삭제 시간복잡도: O(1)

• 내가 가리키는 노드의 바로 앞 노드를 알고자 한다면

  • Singly: O(n)
    • Doubly: O(1)

      // 소멸자
      ~LinkedStack(){ while(!isEmpty()) delete pop();}

  E. 리스트

  : 자료의 접근 위치 - 임의의 위치에서도 삽입/삭제 가능 : 배열로 - 삽입삭제시 오버헤드 : 연결리스트로 - 삽입/삭제 효율적.

a) 배열로 구현한 리스트

• 생성자에서 length = 0 설정
• 공백: length == 0;
• 포화: length == MAX_L_SIZE;
• a.k.a. 밑빠진독 : 배열이 꽉 찼는데 삽입 하고 싶으면 앞으로 n-1개 옮기고 n번째에 넣기 - O(n)

void insert( int post, int e ){
    if (!isFull() && pos >= 0 && pos <= length){
        for(int i = length; i > pos; i--)
            data[i] = data[i-1];
        data[pos] = e;
        length++;
    }
    else error("포화 또는 삽입 위치 오류!");
}
-
void remove( int pos ){
    if (!isEmpty() && 0 <= pos && pos < length){
        for (int i = pos + 1; i < length; i++)
            data[i - 1] = data[i];
        length--;
    }
    else error("공백 또는 삭제 위치 오류!");
}
int getEntry( int pos ){ return data[pos]; }
-
bool find( int item ){
    for (int i = 0; i < length; i++){
        if( data[i] == item) return true;
    return false;
void replace(int pos, int e){
    data[pos] = e;
}
-
// 기출변형 1: item의 인덱스 찾아주는 함수
int where( int item ){
    for ( int i = 0; i < length; i++ ){
        if ( data[i] == item ) return i;
    }
    return -1;
}
-
// 기출변형 2: item을 찾아서 e로 바꿔주는 함수                // 수정 필요!!!
void findAndReplace( int item, int e){
    for( int i = 0; i < length; i++ ){
        if ( data[i] == item ) data[i] = e;
    }
}

b) 연결리스트로 구현한 리스트

by 단순 연결 리스트

• 하나의 링크필드 이용
• 마지막 노드의 링크값은 NULL

[노드 클래스] 에서
-
#include<iostream>

class Node {
    Node* link;
    int data;
public:
    Node(int val = 0) : data(val), link(NULL){}    // 멤버를 초기화
    Node* getLink() { return link; }
    void setLink(Node* next) { link = next; }
    void display() { printf("<%2d>", data); }
    bool hasData(int val) { return data == val; }
    void insertNext(Node* n) {
        if (n != NULL) {
            n -> link = link;
            link = n;
        }
    }
    Node* removeNext() {
        Node* removed = link;
        if (removed != NULL)
            link = removed -> link;
        return removed;
    }
};
-
-
[연결리스트 클래스] 에서        // 수정 필요
-
void clear(){
    while(!isEmpty())
        delete remove(0);
}
-
Node* getEntry(int pos){
    Node* n = &org;
    for (int i = -1; i < pos; i++, n = n -> getLink())
    // i = -1
        if (n == NULL) break;
    return n;
}

: 정렬된 자료를 반으로 계속해서 나누어 탐색하는 방법

>> 코드:

int* binarySearch(int key, const int *target, size_t length) {
    int first = 0, last = length - 1, middle = (first + last) / 2;
    while (first <= last) {
        if (target[middle] == key)     
            return target + middle;

        if (target[middle] > key) 
            last = middle - 1;
        else             
            first = middle + 1;

        middle = (first + last) / 2;
    }      

    return NULL;
}

시간 복잡도:

출처: Learning Never Stops

next() : 문자 또는 문자열을 공백 기준으로 한단어 또는 한문자씩 입력받는다.

nextLine() : 문자 또는 문장 한 라인 전체를 입력받는다.

따라서 "Hello World!"를 입력할 경우 next()는 "Hello"만 입력받고 "World!"는 사라진다. 하지만 nextLine()은 "Hello World!" 전체를 입력받는다.

출처: 혼자 공부하는 자바 p.253

A. Public: 어디서든 접근 가능 B. Protected: 상속관계일 때 접근 가능 C. Private: 해당 클래스에서만 접근 가능

• 굳이 사용하는 이유 : 의도치 않은 코드의 수정을 막고 객체와 객체간의 간섭이 최대한 없도록 하기 위함

[C언어]

#include<iostream>

using namespace std;

class A {
public:
    int num1;

    A() : num1(5), num2(6), num3(7) {}
protected:
    int num2;
private:
    int num3;

};

class B : public A {    
/*A를 상속받은 B
즉, A: 부모 클래스
    B: 자식 클래스*/

public:
    void setNum() {
        num1 = 10;   //컴파일 OK!!
        num2 = 100;  //컴파일 OK!!
        num3 = 1000; //컴파일 Error!!
    }
};

int main(void) {
    A a;

    cout << a.num1 << endl; //컴파일 OK!!
    cout << a.num2 << endl; //컴파일 Error!!
    cout << a.num3 << endl; //컴파일 Error!!
}

• friend 클래스

  : friend로 선언된 다른 클래스의 private 및 protected 멤버에 접근할 수 있게 함. 특정 상황에서 클래스 내에 접근하지 못하도록 private 제한을 두었는데, 필요의 경우 해당 클래스나 함수에서 접근이 가능하도록 하는 것.

HwanShell