01. 실행 컨텍스트란?

• 의미: 실행할 코드에 제공할 환경 정보들을 모아놓은 객체.

• JS의 동작

  [1] 어떤 실행 컨텍스트가 활성화되는 시점에 선언된 변수를 위로 끌어올림(hoisting) [2] 외부 환경 정보를 구성 [3] this 값을 설정

• 역할: 전체 코드의 환경과 순서를 보장

  동일한 환경에 있는 코드들을 실행할 때 필요 환경 정보들을 모아 컨텍스트를 구성, 콜 스택 call stack에 쌓아올렸다가, 가장 위에 쌓여있는 컨텍스와 관련 있는 코드들을 실행하는 식

  동일한 환경*: 하나의 실행 컨텍스트를 구성할 수 있는 방법 - 전역공간, eval 함수, 함수

• 실행 컨텍스트 객체: JS 엔진이 어떤 실행 컨텍스트가 활성화될 때 그 관련된 코드들을 실행하는 데 필요한 환경 정보들을 수집

  • VariableEnvironment: 현재 컨텍스트 내의 식별자들에 대한 정보 + 외부 환경 정보. 선언 시점의 LexicalEnvironment의 스냅샷 snapshot, 변경 사항은 반영되지 않음
  • LexicalEnvironment: 처음에는 VariableEnvironment와 같지만 변경 사항이 실시간으로 반영
  • ThisBinding: this 식별자가 바라봐야 할 대상 객체

02. VariableEnvironment

• 차이: LexicalEnvironment와 같지만 최초 실행 시의 스냅샷을 유지한다는 점이 다름.
• 00실행 컨텍스트를 생성할 때 VariableEnvironment에 정보를 먼저 담고, LexicalEnvironment를 만들고, 이후에는 LexicalEnvironment를 주로 활용.
• 내부 구성(공통): VariableEnvironment와 LexicalEnvironment 둘 모두 내부 구성은 아래와 같이 동일하다.
  • environmentRecord
  • outer-EnvironmentReference

03. LexicalEnvironment

2-3-1 environmentRecord와 호이스팅

• environmentRecord: 현재 컨텍스트와 관련된 코드의 식별자 정보들이 저장.

  • 식별자의 종류

    [1] 컨텍스트를 구성하는 함수에 지정된 매개변수 식별자 [2] 선언한 함수 자체 [3] var로 선언된 변수의 식별자

  • 참고

    전역 실행 컨텍스트는 변수 객체가 아닌, JS 구동 환경이 별도로 제공하는 전역 객체를 활용

    전역 객체*: 브라우저의 window, Node.js의 global 객체 등이 있음 이들은 JS 내장 객체(native object)가 아닌 호스트 객체(host object)로 분류됨

• hoisting: 컨텍스트 내부 전체를 처음부터 끝까지 훑어 나가며 순서대로 수집

  • BUT 코드 실행 전에 수집
  • 실제로 끌어올리지는 않지만, 편의상 JS 엔진은 식별자들을 최상단으로 끌어올린 후 실제 코드를 실행한다고 생각 가능

hoisting 규칙

• 변수명과 함수 선언의 정보를 수집
  • 변수: 선언부와 할당부를 나누어 선언부만 수집
  • 함수 선언: 함수 전체를 수집
  • 함수 표현식: 변수 선언부만 호이스팅
• hoisting 규칙에 의해 전역에서 호출 가능한 함수 선언보다는 선언 이후 실행 가능한 함수 표현식 사용하는 게 best!
  • EX) 전역공간에 동명의 함수가 여럿 존재하는 상황에서의 디버깅!

@매개변수와 변수에 대한 호이스팅

// 매개변수와 변수에 대한 호이스팅 - 원본 코드
function a (x) {  // 수집 대상 1 - 매개 변수 선언
  console.log(x); 
    var x;          // 수집 대상 2 - 변수 선언
    console.log(x);
    var x = 2;      // 수집 대상 3 - 변수 선언
    console.log(x);
}
a(1);

// 매개변수와 변수에 대한 호이스팅 - 호이스팅을 마친 상태
⚠️ 주의: 실제 JS 엔진은 이러한 변환 과정을 거치지 않음. 사람 입장에서의 코드로 변환한 것!

function a (){
    var x;         // 수집 대상 1 - 매개 변수 선언
    ~~var x;         // 수집 대상 2 - 변수 선언
    var x;         // 수집 대상 3 - 변수 선언~~

    x = 1;         // 수집 대상 1의 할당 부분
    console.log(x);
    console.log(x);
    x = 2;         // 수집 대상 3의 할당 부분
    console.log(x);
}
a(1);

실제 코드 실행

[1] 변수 x 선언(메모리 공간 미리 확보, 주솟값 변수 x에 연결) [2] 다시 변수 x 선언, 이미 선언된 변수 x가 있으므로 무시 [3] x에 1 할당 [4] 각 x 출력, 모두 1 출력됨 [5] x에 2 할당(원래 1을 가리키는 주솟값 → 2의 주솟값으로 대치) [6] x 출력, 2 출력됨 [7] 함수 내부의 모든 코드가 실행됐으므로 실행 컨텍스트가 콜 스택에서 제거됨

@함수 선언의 호이스팅

// 원본 코드
function a () {
    console.log(b);
    var b = 'bb';
    console.log(b);
    function b(){}
    console.log(b);
}
a();

// 호이스팅을 마친 상태
function a(){
    var b;
    function b (){}

    console.log(b);
    b = "bbb";
    console.log(b);
    console.log(b);
}
a();

// 함수 선언문을 함수 표현식으로 바꾼 코드
function a(){
    var b;                        // [1] 
    var b = function b (){};      // [2]

    console.log(b);               // [3]  함수 b 출력
    b = "bbb";                    // [4]
    console.log(b);               // [5]  "bbb" 출력
    console.log(b);
}
a();

실행 시

[1] 변수 b 선언 [2] 함수는 별도의 메모리, 그 함수가 저장된 주솟값을 b와 연결된 공간에 저장. 이제 변수 b는 함수를 가리킴 [3] 변수 b에 할당된 함수 b가 출력 [4] 변수 b에 “bbb”를 할당 [5] “bbb” 출력 후 실행 컨텍스트는 콜 스택에서 제거(모든 코드 실행됐으므로)

함수 선언문과 함수 표현식

• 함수 선언문: function 정의부만 존재하고 별도의 할당 명령이 없는 경우

• 함수 표현식: 정의한 function을 별도의 변수에 할당하는 것을 말함

  • 기명 함수 표현식: 함수명을 정의한 함수 표현식
  • 익명 함수 표현식: 함수명을 정의하지 않은 함수 표현식

• 함수 정의하는 3가지 방식

    // 함수를 정의하는 3가지 방식
    function a(){ ... }
    a();  // 실행 OK!
  
    var b = function(){ ... }
    b();  // 실행 OK!
  
    var c = function d(){ ... }
    c();  // 실행 OK!
    d();  // 에러!

  • ⚠️ 기명 함수 표현식 주의

    외부에서는 함수명으로 함수를 호출할 수 없음. 오직 내부에서 함수명으로 함수 호출 가능! 과거) 기명 함수 표현식 - 디버깅 시 어떤 함수인 지 추적하기에 익명 함수 표현식보다 유리한 측면이 있었음 현재) 모든 브라우저 - 익명 함수 표현식의 변수명을 함수의 name 프로퍼티에 할당

@함수 선언문과 함수 표현식

// 원본 코드
console.log(sum(1,2));
console.log(multipy(3,4));

function sum(a,b){  // 함수 선언문 sum
    return a+b;
}

var multiply = function(a,b){   // 함수 표현식 multiply
    return a*b;
}

// 호이스팅을 마친 상태
var sum = function sum(a,b){  // 함수 선언문 전체를 호이스팅
    return a+b;
}
var multiply;                 // 변수는 선언부만 수집

console.log(sum(1,2));
console.log(multipy(3,4));

multifly = function(a,b){     // 변수의 할당부는 원래 자리에 남겨둠
    return a*b;
}

실행 시

[1] sum ← 메모리 공간 확보 후 연결 [2] multiply ← 메모리 공간 확보 후 연결 [3] sum 함수 → 또 다른 메모리 공간에 저장, 그 주솟값을 변수 sum의 공간에 할당. [4] sum 실행 [5] multiply is not a function 이라는 에러 메시지가 출력됨 ← 현재 multiply에는 값이 할당되어 있지 않음. 비어있는 대상을 함수로 여겨 출력하라는 명령이었음.

2-3-2 스코프, 스코프 체인, outerEnvironmentReference

• scope: 식별자에 대한 유효범위
  • ES5까지의 JS는 전역공간을 제외하면 오직 함수에 의해서만 스코프가 생성
• 스코프 체인 scope chain: 식별자의 유효범위를 안에서부터 바깥으로 차례로 검색해나가는 것
  • LexicalEnvironment의 outerEnvironmentReference 활용

스코프 체인

• outerEnvironmentReference: 현재 호출된 함수가 선언될 당시*의 LexicalEnvironment를 참조

  선언될 당시* : A 함수 내부에 B 함수를 선언, B 함수 내부에 C 함수를 선언 함수 C의 outerEnvironmentReference → 함수 B의 LexicalEnvironment를 참조 (함수 C가 선언될 당시) 함수 B의 outerEnvironmentReference → 함수 A의 LexicalEnvironment를 참조 (함수 B가 선언될 당시)

• outerEnvironmentReference는 연결 리스트의 형태

  • 선언 시점의 LexicalEnv를 계속 찾아 올라가면 마지막엔 전역 컨텍스트의 LexicalEnv가 있을 것

• 여러 스코프에서 동일한 식별자를 선언한 경우 - 무조건 스코프 체인 상에서 가장 먼저 발견된 식별자에만 접근이 가능

  • 가장 먼저* : 찾아 ^올라가는^ 형태

@예제

var a = 1;
var outer = function() {
    var inner = function () {
        console.log(a);
        var a = 3;
    };

    inner();
    console.log(a);
};
outer();
console.log(a);

• 설명

  [1] 가장 처음 전역 컨텍스트 활성화 전역 컨텍스트 → environmentRecord = {a, outer} 식별자를 저장 전역 컨텍스트 → outerEnv-Ref = 아무것도 안 담김

  [2] 전역 스코프에서 호이스팅 전역 스코프에 있는 변수 a ← 1, outer ← 함수 할당

  [3] outer(); outer 함수 호출 전역 컨텍스트의 코드는 임시중단, outer 실행 컨텍스트가 활성화, 2번째 줄로 이동

  [4] var outer = function () { outer 실행 컨텍스트 → environmentRecord = {inner} 식별자 저장 outer 실행 컨텍스트 → outerEnv-Ref = [GLOBAL, {a, outer}] [GLOBAL, {a, outer}]* : 전역 컨텍스트 → LexicalEnvironment를 참조복사한 것을 편의상 표기.

  1번째 인자 = 실행 컨텍스트의 이름, 2번째 인자 = environmentRecord 객체

  [5] var inner = function () { outer 스코프에 있는 변수 inner에 함수 할당

  [6] inner();

  inner 함수 호출. outer 실행 컨텍스트 임시중단, inner 실행 컨텍스트 활성화

  [7] var inner = function () { inner 실행 컨텍스트 → environmentRecord = {a} 식별자 저장 inner 실행 컨텍스트 → outerEnv-Ref = [outer, {inner}]

  [8] console.log(a); 식별자 a에 접근, inner 컨텍스트의 envRec에서 a를 검색 undefined 출력

  [9] var a = 3; inner 스코프에 변수 a에 3 할당

  [10] }; inner 함수 실행이 종료, inner 실행 컨텍스트가 콜 스택에서 제거, outer 실행 컨텍스트가 다시 활성화

  [11] console.log(a); 식별자 a 에 접근. 활성화된 실행 컨텍스트의 LexicalEnv에 접근, 매 요소마다 envRec에 a 있는 지 찾아보고, 없으면 outerEnvRef에서 environmentRecord에서 a 찾는 식으로 계속해서 검색

  [12] }; outer 함수 실행 종료 outer 실행 컨텍스트가 콜 스택에서 제거, 바로 아래의 전역 컨텍스트가 다시 활성화

  [13] console.log(a); 식별자 a에 접근 현 활성화된 전역 컨텍스트의 environmentRecord에서 a를 검색 전역 컨텍스트가 콜 스택에서 제거되고 종료

@ 간략 요약 표

• LE = LexicalEnvironment, e = environmentRecord, o = outerEnvironmentReference
• 변수 은닉화
  • 스코프 체인 상에 있는 변수라고 해서 무조건 접근 가능한 것은 아니며, 가장 가까운 실행 컨텍스트에서 어떤 변수가 이미 검색되는 경우, 스코프 체인 검색을 더 이상 진행하지 않음. 즉, 접근할 수 없는 것과 마찬가지.

전역변수와 지역변수

• 전역변수: 전역 공간에서 선언한 변수
• 지역변수: 함수 내부에서 선언한 변수
• 코드의 안전성을 위해 가급적 전역변수 사용을 최소화하고자 노력하는 것이 좋음.

04. this

실행 컨텍스트의 thisBinding에는 this로 지정된 객체가 저장

실행 컨텍스트 활성화 당시, this가 지정되지 않는 경우: this ← 전역 객체가 저장

05. 정리

• 실행 컨텍스트
  • 실행할 코드에 제공할 환경 정보들을 모아놓은 객체
  • 전역 공간에서 자동으로 생성되는 전역 컨텍스트와 eval 및 함수 실행에 의한 컨텍스트 등
  • 활성화 시점에 VariableEnv, LexicalEnv, ThisBinding 정보를 수집
• VariableEnv, LexicalEnv
  • 공통: 실행 컨텍스트 생성 당시 동일 내용
  • 차이
    • LexicalEnv: 함수 실행 도중에 변경되는 사항이 즉시 반영
    • VariableEnv: 초기 상태를 유지
  • 구성
    • environmentRecord: 매개변수명, 변수의 식별자, 선언한 함수의 함수명 수집
    • outerEnvironment-Reference: 바로 직전 컨텍스트의 LexicalEnvironment 정보를 참조하는 outerEnvironmentReference로 구성
• 호이스팅
  • 코드 해석을 수월하게 해 environmentRecord의 수집 과정을 추상화
    • 실행 컨텍스트가 관여하는 코드 집단의 최상단으로 이들을 끌어올린다고 해석하는 것
  • 변수 선언과 값 할당이 동시에 이뤄진 문장: 선언부만 호이스팅, 할당 과정(호출부)는 원래 자리에.
    • 함수 선언문 vs 함수 표현식의 차이 발생
• 스코프
  • 변수의 유효범위
  • outerEnvironmentReference: 해당 함수가 선언된 위치의 LexicalEnvironment를 참조
  • 코드 상에서 어떤 변수에 접근하는 경우 현재 컨텍스트의 LexicalEnvironment를 탐색해서
    • 발견 : 그 값을 반환
    • 발견 못하면 다시 outerEnvRef에 담긴 LexicalEnv를 탐색하는 과정을 거침
    • 전역 컨텍스트까지 탐색해도 해당 변수를 찾지 못하면 undefined를 반환
• 전역변수와 지역변수
  • 전역변수: 전역 컨텍스트의 LexicalEnv에 담긴 모든 변수
  • 그 밖의 함수에 의해 생성된 실행 컨텍스트의 변수들
  • 안전한 코드 구성을 위해 전역변수 사용 최소화

01. 데이터 타입의 종류

기본형 primitive type

숫자 number, 문자열 string, 불리언 boolean, null, undefined, 심볼 symbol (ES6)

• 할당이나 연산 시 값이 담긴 주솟값을 바로 복제함.
• 불변성(immutuability)

참조형 reference type

객체 object, 배열 array, 함수 function, 날짜 date, 정규표현식 RegExp

할당이나 연산 시 값이 담긴 주솟값들로 이루어진 묶음을 가리키는 주소값을 복제함.

02. 데이터 타입에 관한 배경지식

1-2-1 메모리와 데이터

• 비트: 0 또는 1만 표현할 수 있는 하나의 메모리 조각
• 바이트(byte): 8비트, 8개의 비트로 구성

C/C++ 혹은 JAVA는 2바이트(short), 4바이트(int)

Javascript는 숫자의 경우 8바이트를 확보(정수형과 부동소수형 구분을 하지 않음)

모든 데이터는 바이트 단위의 식별자, 더 정확히는 메모리 주솟값을 통해 서로 구분 및 연결이 가능

1-2-2 식별자와 변수

• 변수: 변할 수 있는 데이터
• 식별자: 변수명

03. 변수 선언과 데이터 할당

1-3-1 변수 선언

변수: 변경 가능한 데이터가 담길 수 있는 공간 또는 그릇

var a;

[1] 변수 선언: 컴퓨터는 메모리에서 비어있는 공간 하나를 확보, 임의로 1003번으로 정함. 이 공간의 이름(식별자)을 a라고 지정.

[2] a에 접근: 컴퓨터는 메모리에서 a라는 이름을 가진 주소를 검색해 해당 공간에 담긴 데이터를 반환

1-3-2 데이터 할당

a = 'abc'; // 할당

[1] 데이터 영역의 빈공간(@5004)에 문자열 ‘abc’를 저장

[2] 변수 영역에서 a라는 식별자를 검색(@1003)

[3] 앞서 저장한 문자열의 주소 @5004를 @1003의 공간에 대입

• @왜 변수 영역에 값을 직접 대입하지 않고 굳이 번거롭게 단계를 더 거치는가?

  → 데이터 변환을 자유롭게 + 메모리를 더욱 효율적으로 관리하기 위한 고민의 결과

• JS에서 문자열은 특별히 정해진 규격이 없다. 문자열 변수는 가변적으로 데이터 영역을 차지한다.

• @미리 확보한 공간 내에서만 데이터 변환을 할 수 있다면?

  → 확보된 공간을 변환된 데이터 크기에 맞게 늘리는 작업이 선행되어야 할 것

  → 따라서 변수 영역, 데이터 영역을 분리하는 게 효율적

@문자열 ‘abc’의 마지막의 ‘def’를 추가하자

[1] ‘abcdef’라는 문자열을 새로 만들어 별도의 공간(@1003)에 저장

[2] 변수 영역에서 a라는 식별자를 검색(@1003)

[3] 앞서 저장한 문자열의 주소 @5005를 @1003의 공간에 대입

[4]@5004는 (자신의 주소를 저장하는 변수가 하나도 없다면) 가비지 콜렉터가 수거

@500개의 변수를 생성해 모든 변수에 숫자 5를 할당

→ 데이터 영역이 없다면, 주소 공간 2바이트500개 + 데이터 공간 8바이트500개

→ 데이터 영역이 있으므로 중복 참조해 주소 공간 2바이트500개 + 데이터 공간 8바이트1개

→ IF 변수 중 하나를 다른 숫자로 할당?

⇒ 다른 숫자용으로 데이터 영역 하나 차지, 주소 공간에 주소만 대입

→ → 따라서 변수 영역, 데이터 영역을 분리하면 중복된 데이터에 대한 처리 효율도 높아짐.

04. 기본형 데이터와 참조형 데이터

1-4-1 불변값

• 변수: 변수 영역 메모리 변경 가능
• 상수: 변수 영역 메모리 변경 불가
• 불변값: 데이터 영역 메모리 변경 불가. 변경은 새로 만드는 동작을 통해서만 이뤄짐.

@기본형 데이터는 모두 불변값.

기본형 데이터 ← 숫자, 문자열, boolean, null, undefined, Symbol

var a = "abc"; // [1]
a = a + "def"; // [1]

var b = 5;     // [2]
var c = 5;     // [3]
b = 7;         // [4]

[1] 변수 a에 문자열 ‘abc’를 할당 뒤에 ‘def’를 추가하면 새로운 ‘abcdef’를 만들어 그 주소를 변수 a에 저장

[2] 데이터 영역에서 5를 찾고, 없으면 그제서야 데이터 공간을 하나 만들어 저장, 해당 데이터 공간의 주소를 b에 저장

[3] 이미 만들어둔 데이터 공간의 주소를 c에 저장

[4] 기존에 저장해둔 7의 데이터 공간의 주소를 찾아서 있으면 재활용, 없으면 새로 만들어서 b에 저장.

1-4-2 가변값

• 참조형 데이터의 기본적인 성질은 가변값.
  • 이때 가변은 참조형 데이터 자체를 변경할 경우가 아니라 그 내부의 프로퍼티를 변경할 때만 성립
• 객체의 변수 영역이 별도로 존재
• 설정에 따라 변경 불가능하게 할 수 있고(Object.defineProperty 등), 불변값으로 활용 가능

var obj1 = {
  a: 1,
  b: 'bbb'
};

[1] 변수 영역 빈 공간 @1002를 확보, 그 주소의 이름을 obj로 지정

[2] 데이터 → 여러 개의 프로퍼티로 이뤄진 데이터 그룹 해당 그룹 내의 프로퍼티들을 저장 위해 별도의 변수 영역을 마련, 그 영역의 주소를 @5001에 저장.

[3] @7103 및 @7104에 각각 a와 b라는 프로퍼티 이름을 지정

[4] 데이터 영역에서 숫자 1 검색, 검색 결과가 없으므로 임의로 @5003에 저장, 이 주소를 @7103에 저장. 문자열 ‘bbb’ 역시 임의로 @5004에 저장, 이 주소를 @7104에 저장

@참조형 데이터의 프로퍼티 재할당

var obj1 = {
    a: 1,
    b: 'bbb',
};

obj1.a = 2;

[1] 데이터 영역에서 숫자 2 검색

[2] 검색 결과가 없음, 빈 공간인 @5005에 저장, 이 주소를 @7103에 저장

[3] 이 주소를 @7103에 저장. @7104에 이름 arr를 지정 → 즉 새로운 객체가 아닌 기존의 객체 내부의 값만 바뀐 것!

@중첩된 참조현 데이터(객체)의 프로퍼티 할당

@1002 → @5001 → (@7103 ~ ?) → @7104 → @5003 → (@8104 ~ ?) → @8105 → @5004 → 4 반환

@여기서 재할당 명령을 아래와 같이 내리면?

obj.arr = 'str';

@5003은 더 이상 자신의 주소를 참조하는 변수가 하나도 없게 됨 → GC 수거 대상이 됨.

• 참조 카운트: 어떤 데이터에 대해 자신의 주소를 참조하는 변수의 개수
• 가비지 컬렉터: 런타임 환경에 따라 특정 시점이나 메모리 사용량이 포화 상태에 임박할 때마다 자동으로 수거 대상들을 수거(collecting)
  • 수거된 메모리는 다시 새로운 값을 할당할 수 있는 빈 공간이 됨
• 참조 카운트가 0인 메모리 주소는 가비지 컬렉터의 수거 대상이 됨.

1-4-3 변수 복사 비교

기본형과 참조형의 복사 과정은 동일, 데이터 할당 과정에서 이미 차이 발생, 변수 복사 이후의 동작에도 큰 차이 발생

var a = 10;
var b = a;

var obj1 = {c:10, d:'ddd'};
var obj2 = 'obj1';

@기본형 데이터

@1002 확보, 식별자=b로 지정

식별자 a를 검색해서 @1001에 저장된 값인 @5001을 들고 좀 전에 확보해둔 @1002에 값으로 대입

@참조형 데이터

@1004 확보, 식별자=obj2로 지정

식별자 obj1을 검색해(@1003) 그 값인 @5002를 들고 @1004에 값으로 대입

@변수 복사 이후 값 변경 결과 비교 - 객체의 프로퍼티 변경 시

var a = 10;
var b = a;
var obj1 = {c:10, d:'ddd'};
var obj2 = obj1;

b = 15;
obj2.c = 20;

• 기본형: 변수 a와 b는 서로 다른 주소를 바라보게 됨

• 참조형: 변수 obj1와 obj2는 여전히 같은 객체를 바라보고 있는 상태.

• 결국 코드로 표현하면,

    a !== b
    obj1 === obj2

@변수 복사 이후 값 변경 결과 비교 (2) - 객체 자체를 변경했을 때

var a = 10;
var b = a;
var obj1 = { c:10, d:"ddd"};
var obj2 = obj1;

b = 15;
obj2 = { c:20, d:"ddd"};

• obj2에도 새로운 객체를 할당해서 값을 직접 변경.
• 참조형 데이터가 가변값이라고 설명할 때의 가변은 참조형 데이터 자체를 변경할 경우가 아니라 그 내부의 프로퍼티를 변경할 때만 성립.

05. 불변 객체

1-5-1 불변 객체를 만드는 간단한 방법

불변 객체 immutable object

• 데이터 자체를 변경하고자 하면 기본형 데이터와 마찬가지로 기존 데이터는 변하지 않음
• 내부 프로퍼티를 변경할 필요가 있을 때마다 매번 새로운 객체를 만들어 재할당하기로 규칙을 정하거나 자동으로 새로운 객체를 만드는 도구를 활용

@불변 객체가 필요한 경우

아래 예시에서 정보가 바뀐 시점에 알림을 보내야 함

바뀌기 전의 정보와 후의 정보의 차이를 가시적으로 보여줘야 하는 등의 기능을 구현해야 함

→ 변경 전, 후에 서로 다른 객체를 바라보게 만들어야 함.

var user = {
    name: "Jaenam",
    gender: 'male',
};

var changeName = function (user, newName) {
    var newUser = user;
    newUser.name = newName;
    return newUser;
};

var user2 = changeName(user, 'Jung');

if (user !== user2){
    console.log("유저 정보가 변경되었습니다.");
}

console.log(user.name, user2.name); // Jung Jung
console.log(user === user2);  // true

→ 위 코드를 고친 코드는 아래.

var user = {
    name: "Jaenam",
    gender: 'male',
};

var changeName = function (user, newName) {
    return {
        name: newName,
        gender: user.gender
    };
};

var user2 = changeName(user, 'Jung');

if (user !== user2){
    console.log("유저 정보가 변경되었습니다.");
}

console.log(user.name, user2.name); // Jaenam Jung
console.log(user === user2);  // false

→ 보다 효율적으로 바꾼 코드

var copyObject = function (target) {
    var result = {};
    for (var prop in target) {
        result[prop] = target[prop];
    }
    return result;
};

var user = {
    name: "Jaenam",
    gender: 'male',
};

var user2 = copyObject(user);
user2.name = "Jung"

if (user !== user2){
    console.log("유저 정보가 변경되었습니다.");
}

console.log(user.name, user2.name); // Jaenam Jung
console.log(user === user2);  // false

모두가 규칙을 따르지 않고는 프로퍼티 변경을 할 수 없게끔 시스템적으로 제약을 거는 편이 안전

→ 실제: immutable.js, baobab.js 등의 라이브러리 활용

1-5-2 얕은 복사와 깊은 복사

• 얕은 복사 = shallow copy
  • 바로 아래 단계의 값만 복사
• 깊은 복사 = deep copy
  • 내부의 모든 값들을 하나하나 찾아서 전부 복사하는 방법

@객체의 깊은 복사를 수행하는 범용 함수

var copyObjectDeep = function(target) {
    var result = {};
    if (typeof target === "object" && target !== null) {
        for (var prop in target) {
            result[prop] = copyObjectDeep(target[prop]);
        }
    } else {
        result = target;
    }

    return result;
};

@다른 방법

• hasOwnProperty 메서드를 활용해 프로토타입 체이닝, 상속된 프로퍼티를 복사하지 않게끔 할 수도 있음
• JSON 활용
  • JSON 문법으로 표현된 문자열로 전환, 다시 JSON 객체로 바꿈
  • CF) 메서드(함수)나 숨겨진 프로퍼티(proto, getter/setter 등) JSON으로 변경 불가한 프로퍼티들은 모두 무시
  • httpRequest로 받은 데이터를 저장한 객체를 복사할 때 등 순수한 정보만 다룰 때 활용하기 좋은 방법

06. undefined와 null

undefined

• 사용자가 명시적으로 지정 가능

  접근 시 → 이때의 프로퍼티나 배열의 요소는 고유의 키값(프로퍼티 이름)이 실존, 따라서 순회의 대상이 될 수 있음.

• 값이 존재하지 않을 때 자바스크립트 엔진이 자동으로 부여하기도 함

  접근 시 → 이때의 해당 프로퍼티 내지 배열의 키값 자체가 존재하지 않음

[1] 값을 대입하지 않은 변수, 즉 데이터 영역의 메모리 주소를 지정하지 않은 식별자에 접근할 때

[2] 객체 내부의 존재하지 않는 프로퍼티에 접근하려고 할 때

[3] return 문이 없거나 호출되지 않는 함수의 실행 결과

// 자동으로 undefined를 부여하는 경우

var a;
console.log(a); // undefined, 1 - 값 대입하지 않은 변수

var obj = {a:1};
console.log(obj.a); // 1
console.log(obj.b); // undefined, 2 - 존재하지 않는 프로퍼티에 접근
console.log(b);     // c.f) Reference error - b is not defined

var func = function(){};
var c = func();     // undefined, 3 - return 값이 없으면 undefined를 반환한 것으로 간주
console.log(c);     // undefined

// undefined와 배열
var arr1 = [];
arr1.length = 3;
console.log(arr1); // [empty * 3]

var arr2 = new Array(3);
console.log(arr2); // [empty * 3]

var arr3 = [undefined, undefined, undefined];
console.log(arr3); // [undefined * 3]

// 빈 요소와 배열의 순회

var arr1 = [undefined, 1];
var arr2 = [];
arr2[1] = 1;

arr1.forEach(function(v, i){console.log(v,i);}); // undefined 0 / 1 1 
arr2.forEach(function(v, i){console.log(v,i);}); // 1 1 

arr1.map(function(v, i){return v+i;}); // [NaN, 2]
arr2.map(function(v, i){return v+i;}); // [empty, 2]

arr1.filter(function(v, i){return !v;}); // [undefined]
arr2.filter(function(v, i){return !v;}); // []

arr1.reduce(function(p, c, i){return p + c + i;}); // undefined011
arr2.reduce(function(p, c, i){return p + c + i;}); // 11

arr1은 배열의 모든 요소를 순회해 결과를 출력

arr2은 각 메서드들이 비어 있는 요소에 대해서는 어떠한 처리도 하지 않고 건너뜀

@배열도 객체

→ 존재하지 않는 프로퍼티에 대해서는 순회할 수 없음

→ 객체와 마찬가지로 특정 인덱스에 값을 지정할 때 비로소 빈 공간을 확보, 인덱스를 이름으로 지정하고 데이터의 주솟값을 저장하는 등의 동작을 함.

→ 사용자가 undefined를 명시적으로 부여한 경우 vs 비어있는 요소에 접근할 때 반환되는 경우 차이를 알 수 있음.

null

• 사용 이유: undefined의 혼동을 피하기 위해, “비어있음”을 명시적으로 나타내고 싶을 때 사용

  → undefined의 의미 = 값을 대입하지 않은 변수에 접근하고자 할 때 자바스크립트 엔진이 반환해주는 값으로만 존재할 수 있음

• 주의: typeof null == object

// undefined vs null 비교
var n = null;
console.log(typeof n);       // object

console.log(n == undefined); // true
console.log(n == null);      // true

console.log(n === undefined); // false
console.log(n === null)       // true

• 동등 연산자(equality operator) vs 일치 연산자(identity operator)

  동등 연산자(==)는 두 피연산자의 값이 서로 같으면 참(true)을 반환합니다. 이때 두 피연산자의 타입이 서로 다르면, 비교를 위해 강제로 타입을 같게 변환합니다. 하지만 일치 연산자(===)는 타입의 변환 없이 두 피연산자의 값이 같고, 타입도 같아야만 참(true)을 반환합니다.

  <예시>

    1 == true     => true
    true == true  => true
    1 === true    => false
    true === true => true

07. 정리

• 기본형 = 불변값
• 참조형 = 가변값
• 변수 = 변경 가능한 데이터가 담길 수 있는 공간
• 식별자 = 그 변수의 이름

목표

(0) 환경 설정 및 base code 짜기

(1) hook 사용해보기(useState)

(2) components 사이에 data sharing하는 작업

을 해본다.

각 (0), (1), (2) 목표는 각 실습에 따라 이뤄진다.

React 환경 설정하기

Nodejs 설치하기 & npm 설치하기 & npx 설치하기

node.js 다운로드

https://nodejs.org/en 에서 LTS 버전 다운로드 후 설치(디폴트 설정)

cmd 창에서 node -v 입력 후 버전 확인

cmd 창에서 npm -v 입력 후 버전 확인

npx install

cmd 창에서 아래 입력

npm install -g create-react-app

react 프로젝트 만들기

npx create-react-app yum

or playcode.io/react 에서 수정하기

BASE CODE 복붙

App.js

import logo from "./logo.svg";
import "./App.css";
import React, { useState } from "react";

function Counter() {
  const counter = 0;
  return (
    <div className="Counter-Wrapper">
      <div>COUNTER: {counter}</div>
      <button>+1</button>
      <button>-1</button>
    </div>
  );
}

function App() {
  return (
    <div className="App">
      <Counter />
    </div>
  );
}

export default App;

App.css

.App {
  text-align: center;
  background-color: #282c34;
  min-height: 100vh;
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  font-size: calc(10px + 2vmin);
  color: white;
}

.Counter-Wrapper {
  margin-bottom: 15px;
}

.Counter-Wrapper > div {
  border: 1px solid white;
  padding: 5px;
  border-radius: 5px;
}

.Counter-Wrapper > button {
  margin-top: 15px;
  margin-left: 10px;
  min-height: calc(10px + 3vmin);
  min-width: calc(10px + 5vmin);
  font-size: calc(5px + 2vmin);
}

(1) hook 사용해보기(useState, useEffect)

COUNTER가 증가하고, 감소하도록 함수 Counter를 작성해 준다.

React 이론 설명

⏲️ 리액트에서 데이터가 변해 웹 브라우저에서 실제 DOM에 업데이트할 때 밟는 3가지 절차 ⏲️

1. 데이터를 업데이트하면 전체 UI에서 Virtual DOM에 re-render
2. 이전 Virtual DOM에 있던 내용과 현재 내용을 비교
3. 바뀐 부분만 실제 DOM에 적용함

그래서 아까 [그림 1-6]의 바뀐 DOM 트리가 그 VIrtual DOM 트리로 확인하는 것임.

• useState: state와 state을 변경할 수 있는 함수를 제공해준다. state가 있어야 컴포넌트에 변경된 값이 감지되고, 리렌더됨(reconciliation 과정).

  • 예시 코드

      // 예시
      import React, { useState } from "react";
    
      function App() {
          const [counter, setCounter] = useState(0);
        return (
          <div className="App">
                  {counter}
          </div>
        );
      }

• onClick: button 과 같은 페이지 요소에서 event 발생 시 호출되는 함수 중 하나. 한마디로, button 클릭 시 호출되는 이벤트 함수다.

  • 예시 코드

      <button onClick={()=>{console.log("+1 clicked")}>+1</button>
      // 여기서 ()=>{}는 화살표 함수(JS 문법)다. onClick 이벤트 발생 시 호출되는 함수.

(2) components 사이에 data sharing하는 작업을 해본다.

위 사진과 같이 +1 혹은 -1 버튼 클릭 시, 해당 결과값만큼 특정 문자열이 반복되도록 한다.

• 자식 컴포넌트에서 데이터 변경 작업을 해도 다른 자식 컴포넌트가 해당 사실을 알도록 해야 한다.

• props 전달: 부모 컴포넌트에서 자식 컴포넌트로 전달할 때 인자로 전달한다. 이때 인자를 의미. 그런데 인자로 함수도 전달할 수 있다!

  • 예시 코드

      function Counter({ counter, setCounter }) {
          // ...
      }
    
      // 혹은
      function Counter(props) {
          const counter = props.counter;
          const setCounter = props.setCounter;
          // ...
      }
    
      function App() {
        const [counter, setCounter] = useState(0);
        return (
          <div className="App">
            <Counter counter={counter} setCounter={setCounter} />
          </div>
        );
      }

React 설명

Often you’ll need components to share data and always update together.

To make both MyButton components display the same count and update together, you need to move the state from the individual buttons “upwards” to the closest component containing all of them.

• PC => 애플리케이션에 따라 다양한 일을 함

• 일반적인 임베디드 시스템 => 기능이 정해진 목적에 따라 구성되어 전용 동작을 함 -> 동작 중에 기능이 변화하는 일이 없음. => 실시간성(시간 제약)이 있음

• 동작 환경, 제어 대상에 맞추어 동작하도록 설계해야 함

• 하드 리얼타임: 시간 제약을 만족시키지 않는 경우 중대한 사고

• 소프트 리얼타임: 소프트웨어 업데이트로 처리 속도가 향상되는 때도 있는 실시간성

02. 임베디드 마이크로컴퓨터의 구성

01. 하드웨어의 종류

• CPU : 인간의 두뇌에 해당
• 메모리: 기억하기 위한 장치(ROM, RAM)
• 주변장치(Peripheral): 입출력을 담당하는 장치 (Timer, DMA Controller, Interrupt Controller, Serial Controller, A/D Controller, PWM Controller)

02. CPU와 마이크로컴퓨터

CPU: 계산에 필요한 부품을 하나의 칩으로 합쳐 놓은 것 마이크로컴퓨터: CPU에서 다양한 기능을 탑재한 것.

주변장치: 마이크로 컴퓨터로 실현할 수 있는 기능을 늘리기 위해 추가됨. 즉, 주변에서 접속되는 하드웨어. 마이크로컴퓨터의 CPU로부터 제어됨.

버스: CPU <-> 주변장치는 버스(신호선)에 접속됨. CPU로부터의 지시는 버스를 경유해 전달, 주변장치로부터 출력, 주변장치로부터의 입력은 버스를 경유해 CPU에 전달.

마이크로컴퓨터: 마이크로프로세서 중 1개의 칩 내에 CPU, 일정 용량의 메모리(ROM, RAM 등)와 입출력 제어 인터페이스 회로까지 내장한 것

03. 메모리

LED ON/OFF는 주변장치만으로 구현 가능 BUT 100ms마다 LED ON/OFF 되는 장치는 CPU 없이 구현 불가 BUT 절차로 기술한 '프로그램'은 CPU에 전달해야 하고, 이때 '보관'에 메모리가 필요

ROM: 프로그램 자체를 보관하여 CPU에 절차를 전달하기 위해 사용(읽기 전용 메모리) RAM: CPU가 ROM으로부터 읽어 들인 절차를 실행할 때 이용

ROM

읽기 전용 메모리

프로그램을 보관해서 CPU에서 읽기 요구가 있을 때 프로그램을 읽고 CPU에 프로그램 전달하는 역할을 담당.

사람이 기록한 절차를 기억해서 그 절차에 따른 기능을 CPU에 실행시킴

RAM

프로그램 실행 때 일시적으로 데이터의 보관이 필요할 경우에 사용 ROM은 읽기만이 가능한 메모리이므로 일시적인 보관 장소로는 이용할 수 없기 때문

시리얼 콘솔에 문자를 출력할 때 문자나 숫자는 CPU에서 생성되고, 이것들의 값을 시리얼로 전달하기 위해 RAM에 일시적으로 보관해둔다.

04. 메모리의 종류

ROM: 비휘발성 메모리(non-volatile memory), 전원이 꺼져도 내용이 지워지지 않음 MASK ROM, PROGRAMMABLE ROM

RAM: 휘발성 메모리(volatile memory), 전원이 꺼지면 내용도 지워진다. DRAM(dynamic ram), SRAM(static ram)

05. 버스의 구성

메인 버스 -> 고속 주변 장치(메모리)는 CPU로부터 고속으로 제어하길 바람, 메인 버스로 접속 로컬 버스 -> 저속으로 동작하는 주변장치는 브리지를 경유해서 로컬 버스로 접속

06. 메인 버스의 용도

CPU와 메모리, 또는 주변장치에 접속하기 위한 신호선

• 주소 버스: 메모리나 주변장치에 접근할 특정 위치를 나타내기 위해 이용되는 신호선
• 데이터 버스: 메모리나 주변장치로부터 데이터를 읽어 들이기 위한 신호선. 데이터 버스는 쌍방향으로 되어 있으며 CPU로부터의 출력, CPU로의 입력이 가능하도록 되어 있음.
• 컨트롤 버스: 메모리나 주변장치를 제어하기 위한 신호선. 데이터를 r/w 타이밍, 주변장치와 CPU 간의 제어에 필요한 신호를 전달 위해 사용함

버스 신호는 클럭(타이밍 신호)에 동기화되어 CPU로부터의 지시 대상이 되는 메모리, 주변장치에 지시를 전달하는 데 사용됨.

예시(데이터 R/W)

버스는 CPU에서 지정해서 동작됨.

RAM에서 데이터 읽어 낼 때

RAM을 선택하는 컨트롤 버스의 칩 셀렉트 신호, 읽기 가능 신호, 주소 버스에 읽어 낼 주소 -> 클럭이 시작할 타이밍에 지정

RAM 해당 번지의 데이터가 데이터 버스에 출력됨. 이 출력된 데이터를 CPU가 읽어서 레지스터에 보관함.

RAM에 데이터를 기록할 때

컨트롤 버스의 칩 셀렉트 신호, 쓰기 가능 신호, 주소 버스에 기록하고자 하는 번지, 데이터 버스에 기록할 데이터 -> 클럭이 시작할 타이밍에 지정

쓰기 가능한 동안 RAM의 해당 번지에 기록함.

07. 로컬 버스

메인 버스와 달리 메인 버스의 클럭 속도보다도 저속으로 동작하는 주변 장치를 제어하는 신호선으로 되어 있음. 로컬 버스를 사용해서 많은 주변장치에 접속 가능.

브리지

메인 버스와 로컬 버스를 연결하는 컨트롤러 고속으로 동작하는 메인 버스와 저속으로 동작하는 로컬 버스와의 속도차를 통제해 주는 하드웨어.

FIFO(First In First Out)을 구현한 하드웨어 등에서 저속의 로컬 버스로부터의 데이터를 관리하고, 고속의 메인 버스 타이밍에 맞춰 데이터를 송수신해 주는 하드웨어.

UART

Universal Asynchronous Receiver/Transmitter

동기식 직렬 신호를 병렬 신호로, 역으로 병렬을 직렬로 변환하는 하드웨어, 로컬 버스에 접속됨.

CPU-> UART

CPU에서 8-16비트의 폭으로 데이터가 병렬 전송됨. 복수의 데이터 신호 -> 직렬의 데이터 신호로 변환해 직렬 신호로 송신

UART -> CPU

직렬 신호를 수신받으면 복수의 데이터 신호가 될 때까지 데이터를 담아 놓고, CPU로 데이터를 보내기 위해 병렬로 데이터를 변환 후에 송신

UART <-> UART

UART끼리 통신할 때: 비동기 직렬 통신.

비동기 방식 = 지금부터 데이터를 보낸다, 이것으로 데이터가 끝났다라는 신호를 실제 데이터 사이에 보내서 데이터를 송수신하는 장치끼리 상호 인식을 하며 통신하는 방식.

I2C

시리얼 클록(Serial Clock, SCL)과 양방향 시리얼 데이터(Serial DAta. SDA)의 2개의 신호선을 사용해 통신하는 동기식 직렬 통신.

마스터 장치 <-> 슬레이브 장치

마스터 장치는 개별로 정해진 슬레이브의 주소를 지정해 복수의 슬레이브 장치에 접속할 수 있음.

SPI

시리얼로 제어하는 버스 SCK = 시리얼 클록 SDI = 시리얼 데이터 인 SDO = 시리얼 데이터 아웃

세가지 신호선으로 통신하는 동기식 직렬 통신

버스에서 제어 버스인 슬레이브 셀렉트(SS)를 이용해 마스터에서 (복수의) 슬레이브 디바이스를 선택해 통신할 수 있다.

I2C보다 고속으로 통신이 가능하다. BUT 많은 신호선이 필요함.

SPI는 플래시 메모리 같은 스토리지 디바이스, CPU 간의 통신 등에 많이 사용됨.

08. 주변 장치

DMA(Direct Memory Access) 컨트롤러

직접 메모리에 엑세스하는 주변장치. CPU가 메모리의 데이터 읽쓰를 실행.

-> PIO(Programmed I/O)라고 부름

PIO 방식으로 대량의 데이터를 읽고 쓰면 CPU는 다른 처리를 할 수 없게 됨. DMA -> PIO와 다르게, CPU를 사용X, 메모리의 데이터를 읽쓰 주변장치. -> 즉, 메모리를 읽쓰 도중에 다른 처리를 할 수 있음.

버스 아비터

bus arbiter는 버스를 사용하기 위한 버스 중재를 실시(각 주변장치 사이, 혹은 CPU로부터의 데이터가 충돌 안 나게 함). DMA 실행 시에는 버스 아비터가 버스의 중재를 실시해 데이터가 충돌하지 않도록 제어함

데이터를 메모리에 전송하는 동안 버스를 점유, 메모리 액세스가 느려지는 일도 있음 DMA 컨트롤러의 전송 모드에 메모리 액세스에 영향이 발생하지 않도록 하는 제어 방법도 있으므로 설정을 파악해 두어야 한다.

타이머

임베디드 시스템에서 반드시 이용하는 주변 장치 프로그램에서 주변장치를 주기적으로 감시, 주기적으로 데이터 출력 등 시간 관련 처리를 위해서 필수적인 주변장치

카운터라고 부르는 레지스터에 주기 시간을 설정함. 주기 시간 경과 이후 처리 중간에 끼어들어 그 사실을 CPU에 통지. CPU는 인터럽트를 받아들여 해당 프로그램을 동작시키면서 주기적인 처리를 실현

RTC(Real Time Clock)

시간을 관리하기 위한 주변장치 매초 시간이 갱신됨

CPU가 재개한 때에 정확한 시간을 알 수 있도록 RTC로 시간을 관리

GPIO(General Purpose Input/Output)

CPU가 외부로부터의 입력 및 출력을 범용으로 입출력할 수 있는 포트 실제로 CPU에 연결되어 있는 포트.

CPU의 설정을 통해 활성화/비활성화 가능

외부의 주변장치로부터의 인터럽트 신호에 사용하는 등 범용적으로 입력/출력에 사용 가능

09. 주변장치의 제어 방식

레지스터(제어용 메모리)를 사용해 CPU로부터 제어 각 주변장치에 따라 비트 위치, 비트 폭 등의 구성이 다름. <공통> CPU가 제어할 때 레지스터로의 쓰기/읽기를 통해 제어 <차이> 각 주변장치에 따라 비트위치, 비트 폭 등의 구성이 다름

메모리 맵드 I/O

ROM, RAM과 마찬가지로 주변장치의 레지스터도 메모리로 취급 CPU는 파일을 메모리에서 접근 가능하게 된다. 이를 통해 CPU는 read() 혹은 write()등의 System call을 사용하지 않고 메모리에 data를 읽고 쓰는 것처럼 사용 가능하다.

I/O 맵드 I/O

ROM, RAM은 메모리 공간으로 취급 메모리와 입출력의 주소 공간을 분리한다.

과일로 만든 아이스크림 고르기(lv 1)

GROUP BY

예제 쿼리

예제 01

type 그룹화하여 name 갯수 조회 (컬럼 그룹화)

결과

예제 02

type 1 초과인, type 그룹화하여 name 갯수 조회

결과

예제 03

type 그룹화하여 name 갯수를 가져온 후, 그 중에 갯수가 2개 이상인 데이터 조회 (조건 처리 후에 컬럼 그룹화 후에 조건 처리)

결과

예제 04

type 1 초과인, type 그룹화하여 name 갯수를 가져온 후, 그 중에 갯수가 2개 이상인 데이터를 type 내림차순 정렬로 조회 (내림차순 정렬)

결과

문제

자동차 종류 별 특정 옵션이 포함된 자동차 수 구하기

식품분류별 가장 비싼 식품의 정보 조회하기

JOIN

보호소에서 중성화한 동물

=, <>

집계 함수

SUM(price), AVG(price), COUNT(*), MAX(price), MIN(price)

반올림

round(price, 2)

컬럼명 치환

select price as p

중복 제거

select distinct price

정렬

order by price asc

order by price desc

우선순위에 따라 ,로 배치

와일드 카드

SELECT * FROM tb_product WHERE product_name LIKE CONCAT('%','a','%');

날짜, 시간, 문자열

https://velog.io/@syh0397/SQL-날짜와-시간-문자열-다루기

2. 예문)
   1.DATE_FORMAT(now(), '%Y-%m-%d') // 2011-06-14
   2.DATE_FORMAT(now(), '%Y-%M-%D') // 2011-June-14th
   3.DATE_FORMAT(now(), '%H:%i:%s')  // 22:26:11  ( 24시간 표현 )
   4.DATE_FORMAT(now(), '%h:%i:%s')  // 10:26:11 ( 12시간 표현 )

집합연산

합집합 - UNION

# NULL 값 주는 경우
select id, NULL date
from T1
union
select id, data
from T2;

차집합 - EXCEPT

교집합 - INTERSECT

조인

조건없이 조인(카티전 프로덕트)

SELECT *
FROM CUSTOMER, ORDERS;

또는

SELECT 조회할컬럼
FROM 테이블1
JOIN 테이블2

또는

SELECT 조회할컬럼
FROM 테이블1
CROSS JOIN 테이블2

동등 조인

INNER 조인

SELECT Sales.*, Countries.Country 
FROM Sales 
JOIN Countries 
ON Sales.CountryID = Countries.ID

외부 조인

[FULL OUTER JOIN]

SELECT *
FROM instructor
FULL OUTER JOIN teaches 
ON instructor.id = teaches.id

[LEFT OUTER JOIN]

SELECT *
FROM instructor
LEFT OUTER JOIN teaches 
ON instructor.id = teaches.id

[RIGHT OUTER JOIN]

SELECT *
FROM instructor
RIGHT OUTER JOIN teaches 
ON instructor.id = teaches.id

부속질의

IN, > ALL, < SOME, EXISTS

상위 n개 행 반환

select top 2 price

from products;

<예시>

SELECT userID, addr, mDate 
FROM userTb1
WHERE addr LIKE '%산'

과일로 만든 아이스크림 고르기(lv 1) -> 링크

SELECT ROUND(AVG(DAILY_FEE), 0) AS AVERAGE_FEE
FROM CAR_RENTAL_COMPANY_CAR
WHERE CAR_TYPE='SUV';

재구매가 일어난 상품과 회원 리스트 구하기 (lv 2) -> 링크

SELECT DISTINCT O1.USER_ID AS USER_ID, O1.PRODUCT_ID AS PRODUCT_ID
FROM ONLINE_SALE O1, ONLINE_SALE O2
WHERE O1.USER_ID = O2.USER_ID AND O1.PRODUCT_ID = O2.PRODUCT_ID AND O1.SALES_DATE <> O2.SALES_DATE
    ORDER BY USER_ID ASC, PRODUCT_ID DESC;

오프라인/온라인 판매 데이터 통합하기(lv 4) -> 링크

GROUP BY

조건에 맞는 도서와 저자 리스트 출력하기(lv 2) -> 링크 있었는데요 없었습니다(lv 3) -> 링크 보호소에서 중성화한 동물(lv 4) -> 링크

JOIN

조건에 맞는 도서와 저자 리스트 출력하기(lv 2) -> 링크 있었는데요 없었습니다(lv 3) -> 링크 보호소에서 중성화한 동물(lv 4) -> 링크

👌 참고: MongoDB에서는 조인(lookup 연산)을 되도록 사용하지 말아야 함. 성능이 떨어짐

조인의 종류

내부 조인(inner join)

왼쪽 테이블과 오른쪽 테이블의 두 행이 모두 일치하는 행이 있는 부분만 표기

왼쪽 조인(left outer join)

왼쪽 테이블의 모든 행이 결과 테이블에 표기

오른쪽 조인(right outer join)

오른쪽 테이블의 모든 행이 결과 테이블에 표기

합집합 조인(full outer join)

두 개의 테이블을 기반으로 조인 조건에 만족하지 않는 행까지 모두 표기

행과 열을 가지는 표 형식 데이터를 저장하는 형태의 데이터베이스

SQL이라는 언어를 써서 조작

→ 각각의 제품에 특화시킨 SQL을 사용(오라클 - PL/SQL, MySQL - SQL)

01. MySQL

현재 가장 많이 사용하는 데이터베이스

특징 참고: https://jeong-pro.tistory.com/239

02. PostgreSQL

MySQL 다음으로 개발자들이 선호하는 데이터베이스 기술

디스크 조각이 차지하는 영역을 회수할 수 있는 장치 = VACUUM이 특징

02. NoSQL 데이터베이스

SQL을 사용하지 않는 데이터베이스.

주로 사용자들이 대규모로 확장되는 경우 - redis, graphdb 등으로 교체 혹은 끼워서 서비스를 확장한다.

01. MongoDB

JSON을 통해 데이터를 접근 가능

Binary JSON 형태로 데이터가 저장 → 키-값 데이터 모델에서 확장된 도큐먼트 기반의 데이터베이스

ObjectID: 도큐먼트 생성 때마다 다른 컬렉션에서 중복된 값을 지니기 힘든 유니크한 기본키를 생성

02. redis

인메모리 데이터베이스. 키-값 데이터 모델 기반의 데이터베이스

03. NoSQL과 관계형 데이터베이스의 차이

[RDB]

• 상호 관련성을 가진 테이블 집합으로 구성
• 테이블 사이의 관계는 외래키로 표현
• 테이블은 행과 열로 구성
• 스키마 변경이 어렵다
• scale up 가능, scale out 어려움
• ACID 성질을 가짐(원자성, 일관성, 고립성, 지속성)

[NoSQL]

• 다양한 방식으로 데이터를 표현
• 테이블 사이에 특별히 명시된 제약이나 규칙이 없다
• 스키마가 고정적이지 않고, 매우 유연
• Scale Out 용이
• 연산이 빠르고 빅데이터 & 실시간 연산에 적합

00. 데이터베이스란?

데이터베이스: 일정한 규칙, 혹은 규약을 통해 구조화되어 저장되어 있는 데이터의 모음.

• 데이터베이스 안의 테이터들은 특정 DBMS마다 정의된 쿼리 언어를 통해 삽입, 삭제, 수정, 조회 등을 수행
• 실시간 접근과 동시 공유가 가능

DBMS(DataBase Management System): 해당 데이터베이스를 제어, 관리하는 통합 시스템

01. 엔티티

엔티티: 사람, 장소, 물건, 사건, 개념 등 “여러 개의 속성을 지닌 명사”

• 예) 회원(엔티티) ← 이름, 아이디, 주소, 전화번호 (속성)

약한 엔티티와 강한 엔티티

약한 엔티티: 혼자 존재하지 못하고, 강한 엔티티의 존재 여부에 따라 종속적

• 예) 방 = 약한 엔티티, 건물 = 강한 엔티티

02. 릴레이션

릴레이션: 데이터베이스에서 정보를 구분해 저장하는 기본 단위

→ 엔티티에 관한 데이터를 릴레이션 하나에 담아 저장함.

• 관계형 데이터베이스: 릴레이션 == 테이블, 레코드 - 테이블 - 데이터베이스
• NoSQL 데이터베이스: 릴레이션 == 컬렉션, 도큐먼트 - 컬렉션 - 데이터베이스

03. 속성

속성: 릴레이션에서 관리하는 구체적이며 고유한 이름을 갖는 정보

• 예) 차 → 고유넘버, 바퀴수, 차색깔, 차종…

04. 도메인

도메인: 릴레이션에 포함된 각각의 속성들이 가질 수 있는 값의 집합

• 예) 성별(속성) → 여/남

05. 필드와 레코드

레코드: 테이블에 쌓이는 행 단위의 데이터, 튜플이라고도 함.

필드 타입

01. 숫자 타입

TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT

02. 날짜 타입

DATE(3), DATETIME(8), TIMESTAMP(4)

03. 문자 타입

CHAR, VARCHAR, TEXT, BLOB, ENUM, SET

• CHAR: 테이블을 생성할 때 선언한 길이로 고정되어 저장됨.

• VARCHAR: 가변 길이 문자열. 10글자의 이메일이면 10글자 바이트 + 길이기록용 1바이트로 저장.

  → VARCHAR(1000)으로 선언해도 마찬가지.

• TEXT: 큰 문자열 저장. 게시판의 본문을 저장할 때 사용

• BLOB: 이미지, 동영상 등 큰 데이터 저장에 씀. BUT 보통은 아마존 이미지 호스팅 서비스 = S3를 사용

• ENUM: 문자열을 열거한 타입. 메모리를 적게 사용하는 이점. 약 6만 5천개의 요소 넣을 수 있음.

• SET: ENUM과 비슷, 여러 개의 데이터를 선택 가능, 비트 단위의 연산 가능, 최대 64개의 요소

06. 관계

테이블은 서로의 관계가 정의되어 있고, 이를 관계화살표로 나타낸다.

01. 1:1 관계

유저당 장바구니는 1개씩. 장바구니도 1개의 유저만 담는다.

→ 테이블이 2개!

02. 1:N 관계

장바구니당 여러 개의 상품을 담을 수 있다.

하나도 넣지 않는 0개의 경우도 있으니 0도 포함되는 화살표를 통해 표현해야 한다.

03. N:M 관계

학생과 강의의 관계.

강의는 여러 명의 학생이 참여하기도 하고, 학생은 여러 개의 강의를 수강할 수 있다.

학생_강의 라는 테이블을 만들어서 각각 1:N, 1:M이라는 관계를 갖는 테이블 두개로 나누어서 설정.

07. 키

테이블 자체의 인덱스를 위해 설정된 장치 → 기본키, 외래키, 후보키, 슈퍼키, 대체키가 있음

• 유일성: 중복되는 값이 없음.
• 최소성: 필드를 조합하지 않고 최소 필드만 써서 키를 형성할 수 있는 것.

01. 기본키 PRIMARY KEY ⭐

유일성과 최소성을 만족하는 키.

자연키와 인조키 중 택(보통 인조키 택)

• 자연키: 중복된 값들을 제외하며 중복되지 않는 것을 자연스레 뽑다가 나오는 키. 가변성
  • 예) 주민등록번호
• 인조키: 인위적으로 생성한 키. 변하지 않음.
  • 예) 인위적으로 부여한 고유 식별자(auto increment, sequence 등으로 설정)

02. 외래키 ⭐

다른 테이블의 기본키를 그대로 참조하는 값으로 엔티티들간의 관계를 식별하는 데 사용

중복 가능.

03. 후보키

기본키가 될 수 있는 후보들

유일성, 최소성을 동시에 만족하는 키

04. 대체키

후보키가 두 개 이상인 경우 → 어느 한개를 기본키로 지정하고 “남은 후보키”들

05. 슈퍼키

각 레코드를 유일하게 식별할 수 있는 유일성을 갖춘 키

동기(synchronous)와 비동기(asynchronous) 실행

하드 디스크에서 파일을 읽는다고 생각해 보자. SSD가 아니라 하드 디스크를 사용하면 임의의 위치에 쓰여져 있는 파일을 읽는데 시간이 오래 걸림. -> 램에서 데이터를 읽어내는 데 50나노초가 걸리는데, 그에 비해 약 8만배 느림.

동기적인 작업

string txt = read("a.txt"); // 5ms
string result = do_something_with_txt(txt); // 5ms
do_other_computation(); // 5ms 걸림 (CPU 로 연산을 수행함)

위 코드가 순차적으로 실행된다고 하자.

1번에 1개씩 순차적으로 실행되는 작업을 동기적(synchronous)으로 실행된다고 부름 동기적인 작업들은 한 작업이 끝날 때까지 다음 작업으로 이동하지 않기 때문.

비동기적인 작업

프로그램의 실행이 한 갈래가 아니라 여러 갈래로 갈라져서 동시에 진행되는 것

void file_read(string* result) {
  string txt = read("a.txt"); // (1)
  *result = do_something_with_txt(txt);
}

int main() {
  string result;
  thread t(file_read, &result);
  do_other_computation(); // (2)
  t.join();
}

1. (1) 파일 입출력을 맡겨 두다가,
2. CPU 놀지 않고 (2) 먼저 하다가 스레드 끝남.
3. 이후 join 수행으로 다시 file_read 스레드를 실행,
4. 하드 디스크에서 a.txt 파일의 내용이 도착해 있으므로, do_something_with_txt를 바로 실행함.

JS와는 달리 명시적으로 쓰레드를 생성해서 적절히 수행해야 했음 -> C++11 도입 이후 비동기적 실행을 할 수 있게 해주는 도구를 제공해 줌.

std::promise 와 std::future

어떤 데이터를 다른 스레드를 통해 처리해서 받아내는 것.

어떤 스레드 T를 사용해서, 비동기적으로 값을 받아내겠다 : 미래에(future) 쓰레드 T가 원하는 데이터를 돌려 주겠다 라는 약속(promise)라고 볼 수 있음.

#include <future>
#include <iostream>
#include <string>
#include <thread>

using std::string;

void worker(std::promise<string>* p) {
  // 약속을 이행하는 모습. 해당 결과는 future 에 들어간다.
  p->set_value("some data");
}

int main() {
  std::promise<string> p;

  // 미래에 string 데이터를 돌려 주겠다는 약속.
  std::future<string> data = p.get_future();
  std::thread t(worker, &p);

  // 미래에 약속된 데이터를 받을 때 까지 기다린다.
  data.wait();

  // wait 이 리턴했다는 뜻이 future 에 데이터가 준비되었다는 의미.
  // 참고로 wait 없이 그냥 get 해도 wait 한 것과 같다.
  std::cout << "받은 데이터 : " << data.get() << std::endl;
  t.join();
}

promise 객체를 정의할 때, 연산을 수행하고 돌려줄 객체의 타입을 템플릿 인자로 받음. 우리의 경우 string 객체를 돌려줄 예정이므로 string을 전달함.

❗ future에서 get 함수 호출하면 설정된 객체가 이동해 절대로 get을 2번 호출하면 안됨.

promise: 생산자 - 소비자 패턴에서 마치 생산자(producer)의 역할을 수행하고, future는 소비자(consumer)의 역할을 수행한다고 볼 수 있음.

shared_future

여러 개의 스레드에서 future를 get하고 싶을 때 사용

packaged_task

promise-future 패턴을 비동기적 함수(Callable)의 리턴값에 간단히 적용할 수 있는 packaged_task 라는 것을 지원.

future는 packaged_task가 리턴하는 future에서 접근할 수 있음.

int some_task(int x) { return 10 + x; }
int main() {
  // int(int) : int 를 리턴하고 인자로 int 를 받는 함수. (std::function 참조)
  std::packaged_task<int(int)> task(some_task);
  std::future<int> start = task.get_future();

  std::thread t(std::move(task), 5);
  std::cout << "결과값 : " << start.get() << std::endl;
  t.join();
}

packaged_task는 비동기적으로 수행할 함수 자체를 생성자의 인자로 받음. 템플릿 인자로 해당 함수의 타입을 명시해야 함.

packaged_task는 전달된 함수를 실행해서, 그 함수의 리턴값을 promise에 설정함.

이때 packaged_task는 복사 생성이 불가능하므로, 명시적으로 move해 줘야 함. 쓰레드에 굳이 promise를 전달하지 않아도 알아서 packaged_task가 함수의 리턴값을 처리해줘서 매우 편리함.

std::async

std::async 에 어떤 함수를 전달한다면, 아예 쓰레드를 알아서 만들어서 해당 함수를 비동기적으로 실행하고, 그 결과값을 future 에 전달함.

std::future<int> lower_half_future =
std::async(std::launch::async, sum, cref(v), 0, v.size() / 2);

async 함수는 인자로 받은 함수를 비동기적으로 실행한 후, 해당 결과값을 보관할 future를 리턴함.

첫번째 인자로 아래 두가지 경우가 가능

• std::launch::async : 바로 쓰레드를 생성해서 인자로 전달된 함수를 실행한다.
• std::launch::deferred : future 의 get 함수가 호출되었을 때 실행한다. (새로운 쓰레드를 생성하지 않음), 즉 동기적으로 실행됨

#include <future>
#include <iostream>
#include <thread>

int do_work(int x) {
  // x 를 가지고 무슨 일을 한다.
  std::this_thread::sleep_for(std::chrono::seconds(3));
  return x;
}

void do_work_parallel() {
  auto f1 = std::async([]() { do_work(3); });
  auto f2 = std::async([]() { do_work(3); });
  do_work(3);
  f1.get();
  f2.get();
}

void do_work_sequential() {
  do_work(3);
  do_work(3);
  do_work(3);
}

int main() { do_work_parallel(); }

3 개의 do_work 함수를 동시에 각기 다른 쓰레드에서 실행한 덕분에 3 초 만에 끝난다.

CPU와 컴퓨터 메모리(RAM)은 물리적으로 떨어져 있음. 따라서 CPU에서 메모리를 읽는데 걸리는 시간: 약 42사이클(add 한번 하는데 걸리는 시간: 1사이클)

캐시

CPU 칩 안에 있는 조그마한 메모리. 램과는 달리 CPU에서 연산을 수행하는 부분이랑 거의 붙어 있어, 읽기/쓰기 속도가 매우 빠름

CPU에서 차례로 가장 많이 접근하는 메모리 영역: L1 > L2 > L3 캐시 순

CPU가 특정 주소에 있는 데이터에 접근하려 하면

1. 일단 캐시에 있는 지 확인
2. 캐시에 있다면 해당 값을 읽음(Cache hit)
3. 없으면 메모리까지 갔다가 옴(Cache miss)

CPU가 어떻게 어느 영역의 메모리에 자주 접근할 지 어떻게 아는가? -> 알 수 없다.

CPU에서 캐시가 작동하는 방식은

• 메모리를 읽으면 일단 캐시에 저장한다.
• 만일 캐시가 다 차면 특정 방식에 따라 처리한다.

이때 특정 방식에는 대표적으로 LRU 방식이 있음(Least Recently Used). 최근에 접근한 데이터를 자주 반복해서 접근하면 매우 유리함.

컴퓨터 컴파일 실행 순서

int a = 0;
int b = 0;

void foo() { 
  a = b + 1; 
  b = 1;
}

그런데 이때 a = b + 1 부분의 실행이 끝나기 전에 b = 1이 먼저 실행이 끝남. -> 만약 다른 쓰레드가 있어 a와 b의 값을 확인했을 때, 코드가 순서대로 실행되었으면 b =1이면 a = 1이어야 하지만, a=0인데 b=1일 수 있다.

CPU 파이프라이닝

한 작업이 끝나기 전에, 다음 작업을 시작하는 방식으로 동시에 여러 개의 작업을 동시에 실행하는 것

실제 CPU에서 명령어를 실행할 때: fetch(명령어 읽음), decode(읽은 명령어가 뭔지 해석), execute(해석된 명령어를 실행), write(결과를 씀)의 과정을 거침.

그런데 예컨데, 세탁이나 빨래 개기는 30분인데 건조가 3시간이나 걸려서 건조기 기다리느라 빨래를 계속할 수 없다면, 비효율적일 수 있다.

따라서 컴파일러는 CPU의 파이프라인을 효율적으로 활용할 수 있도록 명령어를 재배치함. 또한 컴파일러가 아니더라도, 캐시 상 더 빨리 처리할 수 있는 걸 CPU에서 먼저 실행할 수도 있음.

수정 순서 modification order

수정 순서: 만약 어떤 객체의 값을 실시간으로 확인할 수 있는 전지전능한 무언가가 있다고 했을 때, 해당 객체의 값의 변화를 기록한 것

C++의 모든 객체들은 수정 순서(modification order)라는 것을 정의할 수 있음. 즉, 원자적 연산을 할 경우 모든 쓰레드에서 같은 객체에 대해 동일한 수정 순서를 관찰할 수 있다.

💡 BUT 같은 시간에 변수 a의 값을 관찰했다고 해서 굳이 모든 쓰레드들이 동일한 값을 관찰할 필요는 없다.

-> 쓰레드 간에 같은 시간에 변수의 값을 읽었을 때 다른 값을 리턴할 수 있음. -> CPU 캐시가 각 코어별로 존재하기 때문. -> 각 코어가 각각 자신들의 L1, L2 캐시들을 가지고 있음(동기화 작업이 필요하나, 시간을 꽤나 잡아먹음)

원자성

원자적인 연산이 아닌 경우: 모든 스레드에서 같은 수정 순서를 관찰할 수 있음이 보장되지 않음. 직접 적정한 동기화 방법을 통해 처리해야 함.

원자적: CPU가 명령어 1개로 처리하는 명령. 중간에 다른 스레드가 끼어들 여지가 전혀 없는 연산.

#include <atomic>
#include <iostream>
#include <thread>
#include <vector>

void worker(std::atomic<int>& counter) {
  for (int i = 0; i < 10000; i++) {
    counter++;
  }
}

int main() {
  // ❗ 이레와 같은 아토믹 객체를 만들 수 있음.
  std::atomic<int> counter(0);
  std::vector<std::thread> workers;
  for (int i = 0; i < 4; i++) {
    workers.push_back(std::thread(worker, ref(counter)));
  }
  for (int i = 0; i < 4; i++) {
    workers[i].join();
  }
  std::cout << "Counter 최종 값 : " << counter << std::endl;
}

atomic의 템플릿 인자로 원자적으로 만들고 싶은 타입을 전달할 수 있음.

그런데 CPU에 따라 어느 CPU에서 실행할 지 컴파일러가 알고 있음 -> CPU 특이적인 명령어를 제공할 수 있다는 걸 is_lock_free 함수로 알 수 있음.

memory order

atomic 객체들은 원자적 연산 시, 메모리 접근 방식을 지정 가능.

memory_order_relaxed

가장 느슨한 조건. memory_order_relaxed 방식으로 메모리에서 읽거나 쓸 경우, 주위의 다른 메모리 접근들과 순서가 바뀌어도 무방함.

#include <atomic>
#include <cstdio>
#include <thread>
#include <vector>

using std::memory_order_relaxed;

void t1(std::atomic<int>* a, std::atomic<int>* b) {
  b->store(1, memory_order_relaxed); // b = 1 (쓰기)
  int x = a->load(memory_order_relaxed); // x = a (읽기)
  printf("x : %d \n", x);
}

void t2(std::atomic<int>* a, std::atomic<int>* b) {
  a->store(1, memory_order_relaxed); // a = 1 (쓰기)
  int y = b->load(memory_order_relaxed); // y = b (읽기)
  printf("y : %d \n", y);
}

int main() {
  std::vector<std::thread> threads;
  std::atomic<int> a(0);
  std::atomic<int> b(0);

  threads.push_back(std::thread(t1, &a, &b));
  threads.push_back(std::thread(t2, &a, &b));
  for (int i = 0; i < 2; i++) {
    threads[i].join();
  }
}

store과 load는 atomic 객체들에 대해 원자적으로 쓰기, 읽기를 지원해 주는 함수.

장점

CPU에서 메모리 연산 순서에 관련해서 무한한 자유를 줌. -> CPU에서 매우 빠른 속도로 실행함.

즉, 위 경우가 아닌 counter++ 10000번씩, 4개의 쓰레드로 ++하는 경우 더 유용함. 비록 다른 메모리연산들 보다 counter++ 이 늦게 된다고 하더라도 결과적으로 증가되기만 하면 문제 될게 없기 때문(순서가 중요하지 않은 경우에 더 유용!)

단점

위 코드에서 결과로 x : 0 y : 0 가 나올 수도 있음.

즉, 아래와 같이 CPU가 코드 순서를 재배치해서 실행할 수도 있음.

int x = a->load(memory_order_relaxed); // x = a (읽기)
b->store(1, memory_order_relaxed); // b = 1 (쓰기)

동기화: memory_order_acquire 과 memory_order_release

#include <atomic>
#include <iostream>
#include <thread>
#include <vector>

using std::memory_order_relaxed;

void producer(std::atomic<bool>* is_ready, int* data) {
  *data = 10;
  is_ready->store(true, memory_order_relaxed);
  // ❗ *data = 10과 순서가 바뀌어서 실행되면 is_ready가 true라도 *data = 10이 실행이 끝나지 않을 수 있음.
}

void consumer(std::atomic<bool>* is_ready, int* data) {
  // data 가 준비될 때 까지 기다린다.
  while (!is_ready->load(memory_order_relaxed)) {
  }
  std::cout << "Data : " << *data << std::endl;
}

int main() {
  std::vector<std::thread> threads;
  std::atomic<bool> is_ready(false);
  int data = 0;

  threads.push_back(std::thread(producer, &is_ready, &data));
  threads.push_back(std::thread(consumer, &is_ready, &data));

  for (int i = 0; i < 2; i++) {
    threads[i].join();
  }
}

*data = 10과 순서가 바뀌어서 실행되면 is_ready가 true라도 *data = 10이 실행이 끝나지 않을 수 있기 때문에, consumer 스레드에서 is_ready가 true가 되어도 제대로 된 data를 읽을 수 없음.

이건 consumer 스레드에서도 마찬가지임.

while (!is_ready->load(memory_order_relaxed)) {
}
std::cout << "Data : " << *data << std::endl;

위 코드에서 data를 읽는 부분과 is_ready에서 읽는 부분 순서가 바뀌면, is_ready가 true가 되기 전의 data값을 읽을 수 있음.

-> memory_order_relaxed를 사용할 수 없음.

#include <atomic>
#include <iostream>
#include <thread>
#include <vector>

void producer(std::atomic<bool>* is_ready, int* data) {
  *data = 10;
  is_ready->store(true, std::memory_order_release);
      // ❗ 1. memory_order_release: 해당 명령 이전의 모든 메모리 명령들이 해당 명령 이후로 재배치되는 것을 금지함.
}

void consumer(std::atomic<bool>* is_ready, int* data) {
  // data 가 준비될 때 까지 기다린다.
  while (!is_ready->load(std::memory_order_acquire)) {
  }
  // ❗ 2. 같은 변수를 memory_order_acquire으로 읽는 쓰레드가 있으면, memory_order_release 이전에 오는 모든 메모리 명령들이 해당 쓰레드에 의해서 관찰될 수 있어야 함.
  std::cout << "Data : " << *data << std::endl;
}

int main() {
  std::vector<std::thread> threads;
  std::atomic<bool> is_ready(false);
  int data = 0;

  threads.push_back(std::thread(producer, &is_ready, &data));
  threads.push_back(std::thread(consumer, &is_ready, &data));

  for (int i = 0; i < 2; i++) {
    threads[i].join();
  }
}

1. memory_order_release: 해당 명령 이전의 모든 메모리 명령들이 해당 명령 이후로 재배치되는 것을 금지함.
2. 같은 변수를 memory_order_acquire으로 읽는 쓰레드가 있으면, memory_order_release 이전에 오는 모든 메모리 명령들이 해당 쓰레드에 의해서 관찰될 수 있어야 함. (❓) 즉, 해당 명령 뒤에 오는 모든 메모리 명령들이 해당 명령 위로 재배치되는 것을 금지함.

따라서 이 두 개의 다른 스레드들이 같은 변수의 release, acquire 를 통해 동기화(synchronize)를 수행하게 됨.

memory_order_acq_rel

acquire와 release를 모두 수행하는 것. 읽기, 쓰기를 모두 수행하는 명령들 예를 들어 fetch_add와 같은 함수 속에서 사용될 수 있음.

memory_order_seq_cst

메모리 명령의 순차적 일관성을 보장.

순차적 일관성

메모리 명령 재배치도 없고, 모든 쓰레드에서 모든 시점에 동일한 값을 관찰할 수 있는 방식

특징

• 멀티 코어 시스템에서 memory_order_seq_cst가 꽤나 비싼 연산임.
• 인텔, AMD x86 CPU는 사실 거의 순차적 일관성이 보장됨. memory_order_seq_cst를 강제해도 그 차이가 그렇게 크지 않음.
• ARM 계열의 CPU와 같은 경우 순차적 일관성을 보장하기 위해 CPU의 동기화 비용이 매우 큼.

• 따라서 정말 꼭 필요할 때만 사용해야 함.

경쟁 상태(race condition)

서로 다른 쓰레드들이 동일한 자원을 사용할 때 발생하는 문제

Race condition

#include <iostream>
#include <thread>
#include <vector>

void worker(int& counter) {
  for (int i = 0; i < 10000; i++) {
  // ❗ 문제 발생
    counter += 1;
  }
}

int main() {
  int counter = 0;
  std::vector<std::thread> workers;

  for (int i = 0; i < 4; i++) {
  // 레퍼런스로 전달하려면 ref 함수로 감싸야 한다 (지난 강좌 bind 함수 참조)
    workers.push_back(std::thread(worker, std::ref(counter)));
  }

  for (int i = 0; i < 4; i++) {
    workers[i].join();
  }

  std::cout << "Counter 최종 값 : " << counter << std::endl;
}

CPU 간단 소개

CPU: 컴퓨터의 모든 연산이 발생하는 두뇌

CPU의 연산: CPU의 레지스터라는 곳에 데이터를 기록한 다음에 연산을 수행해야 함.

모든 데이터들 = 메모리에 저장, 연산할 때: 메모리 -> 레지스터로 값을 가져오고 빠르게 연산을 하고, 다시 메모리에 가져다 놓는 식으로 작동

뮤텍스(mutex)

위 코드의 결과로 이상한 게 나올 수 있다. <- counter += 1을 두번 했는데 결과는 한번만 한것과 같은 효과를 가질 수 있기 때문. (쓰레드가 counter에 서로 쓰려고 해서 생기는 문제)

쓰레드를 어떻게 스케둘링할 지는 운영체제가 마음대로 결정하는 것이기 때문. 멀티쓰레딩을 했을 때의 문제점이다.

뮤텍스: 한번에 한 쓰레드에서만 위 코드를 실행시킬 수 있다.(경찰관 역할)

#include <iostream>
#include <mutex> // mutex 를 사용하기 위해 필요
#include <thread>
#include <vector>

void worker(int& result, std::mutex& m) {
  for (int i = 0; i < 10000; i++) {
    m.lock();
    result += 1;
    m.unlock();
  }
}

int main() {
  int counter = 0;
  std::mutex m; // 우리의 mutex 객체
  std::vector<std::thread> workers;

  for (int i = 0; i < 4; i++) {
    workers.push_back(std::thread(worker, std::ref(counter), std::ref(m)));
  }

  for (int i = 0; i < 4; i++) {
    workers[i].join();
  }

  std::cout << "Counter 최종 값 : " << counter << std::endl;
}

mutex: 상호 배제(mutual exclusion)

m.lock() -> 뮤텍스 m을 나만 쓴다.(1번에 1 스레드에서만 m의 사용 권한) 다른 스레드에서 m.lock()을 하면 m을 소유한 스레드가 m.unlock()을 통해 m을 반환 때까지 무한정 기다림.

result += 1은 결국 한 스레드만이 유일하게 실행할 수 있음.

임계영역(critical section)

스레드만이 유일하게 실행할 수 있는 코드 부분

데드락

m.unlock() 코드를 지우면, 뮤텍스를 취득한 스레드가 unlock을 하지 않으므로, 다른 모든 스레드들이 기다리게 됨. 본인도 마찬가지로 m.lock()을 다시 호출, unlock을 하지 않았으므로 본인 역시 기다림.

-> 취득한 뮤텍스는 사용이 끝나면 반드시 반환을 해야 함.

lock guard

std::lock_guard<std::mutex> lock(m);

lock guard 객체는 뮤텍스를 인자로 받아서 생성, 이때 생성자에서 뮤텍스를 lock하게 됨. lock guard가 소멸될 때 알아서 lock했던 뮤텍스를 unlock하게 됨.

사용자가 따로 unlock을 신경 쓰지 않아도 되서 매우 편리.

데드락 deadlock

데드락이 발생하는 조건은 다음과 같이 worker1, worker2를 실행했을 때

// worker1
std::lock_guard<std::mutex> lock1(m1);
std::lock_guard<std::mutex> lock2(m2);

// worker2
std::lock_guard<std::mutex> lock2(m2);
std::lock_guard<std::mutex> lock1(m1);

서로가 필요한 뮤텍스가 서로에게 있기 떄문에 모두 이러지도 저러지도 못함.

데드락 극복하기

한 스레드에게 우선권을 주는 방법이 있다.

쓰레드로 비유하면, 한 스레드가 다른 스레드에 비해 우위를 갖게 된다면, 한 스레드만 열심히 일하고 다른 스레드는 일할 수 없는 기아 상태(starvation)가 발생할 수 있음.

void worker2(std::mutex& m1, std::mutex& m2) {
  for (int i = 0; i < 10; i++) {
    while (true) {
      m2.lock();
      // m1 이 이미 lock 되어 있다면 "야 차 빼" 를 💥스스로💥 수행하게 된다.
      if (!m1.try_lock()) {
        m2.unlock();
        continue;
      }
      std::cout << "Worker2 Hi! " << i << std::endl;
      m1.unlock();
      m2.unlock();
      break;
    }
  }
}

일단 m2는 아무 문제 없이 lock이 가능. m1을 lock할 때: worker1이 m1을 lock하고 있는 경우 -> 원래는 이도저도 못했음.

try_lock: lock할 수 있으면 lock하고 true 리턴, 아니면 기다리지 않고 false 리턴

m1.try_lock()이

• true를 리턴했으면 worker2가 m1, m2를 성공적으로 lock한 상황, 그대로 처리하면 됨.
• false를 리턴했으면 worker1이 이미 m1을 lock했다는 의미. worker1에게 우선권을 줘야 하기 때문에 이미 얻은 m2 역시 worker1에게 제공해 줌.

참고: C++ Concurrency In Action, 데드락 상황을 피하기 위해 가이드라인을 제공.

중첩된 Lock을 사용하는 것을 피해라.

모든 스레드들이 최대 1개의 lock만을 소유하도록 하자.

Lock을 소유하고 있을 때 유저 코드를 호출하는 것을 피해라.

유저 코드에서 Lock을 소유할 수도 있기 때문에 중첩된 lock을 얻는 걸 피하려면 lock 소유 시 유저 코드를 호출하는 것을 지양해야 함.

Lock들을 언제나 정해진 순서로 획득해라.

반드시 정해진 순서로 획득하자. 앞서도 worker1이 m1, m2 순으로, worker2가 m2, m1 순으로 lock했기 때문에 발생한 문제였다.

생산자와 소비자의 패턴

• 생성자: 무언가 처리할 일을 받아오는 쓰레드
• 소비자: 받은 일을 처리하는 쓰레드

#include <chrono> // std::chrono::miliseconds
#include <iostream>
#include <mutex>
#include <queue>
#include <string>
#include <thread>
#include <vector>

void producer(std::queue<std::string>* downloaded_pages, std::mutex* m,
int index) {
  for (int i = 0; i < 5; i++) {
    // 웹사이트를 다운로드 하는데 걸리는 시간이라 생각하면 된다.
    // 각 쓰레드 별로 다운로드 하는데 걸리는 시간이 다르다.
    std::this_thread::sleep_for(std::chrono::milliseconds(100 * index));
    std::string content = "웹사이트 : " + std::to_string(i) + " from thread(" + std::to_string(index) + ")\n";
    // data 는 쓰레드 사이에서 공유되므로 critical section 에 넣어야 한다.
    m->lock();
    downloaded_pages->push(content);
    m->unlock();
  }
}

void consumer(std::queue<std::string>* downloaded_pages, std::mutex* m,
int* num_processed) {
  // 전체 처리하는 페이지 개수가 5 * 5 = 25 개.
  while (*num_processed < 25) {
    m->lock();
    // 만일 현재 다운로드한 페이지가 없다면 다시 대기.
    // 다른 스레드에게 기회를 줌!
    if (downloaded_pages->empty()) {
      m->unlock(); // (Quiz) 여기서 unlock 을 안한다면 어떻게 될까요?
      // 10 밀리초 뒤에 다시 확인한다.
      std::this_thread::sleep_for(std::chrono::milliseconds(10));
      continue;
    }

    // 맨 앞의 페이지를 읽고 대기 목록에서 제거한다.
    std::string content = downloaded_pages->front();
    downloaded_pages->pop();
    (*num_processed)++;
    m->unlock();

    // content 를 처리한다.
    std::cout << content;
    std::this_thread::sleep_for(std::chrono::milliseconds(80));
  }
}

int main() {
  // 현재 다운로드한 페이지들 리스트로, 아직 처리되지 않은 것들이다.
  std::queue<std::string> downloaded_pages;
  std::mutex m;
  std::vector<std::thread> producers;

  for (int i = 0; i < 5; i++) {
    producers.push_back(std::thread(producer, &downloaded_pages, &m, i + 1));
  }

  int num_processed = 0;
  std::vector<std::thread> consumers;

  for (int i = 0; i < 3; i++) {
    consumers.push_back(
    std::thread(consumer, &downloaded_pages, &m, &num_processed));
  }

  for (int i = 0; i < 5; i++) {
    producers[i].join();
  }

  for (int i = 0; i < 3; i++) {
    consumers[i].join();
  }
}

producer: 인터넷 페이지를 다운로드 받음(큐에 집어넣음) consumer: 다운로드받은 인터넷 페이지를 처리함

여기에서 consumer 스레드가 10ms마다 downloaded_pages에 할 일이 있는 지 확인하고 없으면 다시 기다리는 형태를 취하고 있음. -> 비효율적임!

-> producer에서 데이터가 뜸하게 오는 것을 알면 그냥 consumer는 아예 재워놓고, producer에서 데이터가 오면 consumer를 깨우는 방식이 나을 수 있음. 쓰레드를 재워놓으면 다른 쓰레드들이 일을 할 수 있기 때문(CPU 효율적으로 사용)

condition_variable

downloaded_pages 가 empty() 가 참이 아닐 때 까지 자라 라는 명령을 내릴 수 있음.

작업 관리자를 실행하면, 막대한 양의 프로세스가 나오는 것을 볼 수 있음

프로세스: 운영체제에서 실행되는 프로그램의 최소 단위, CPU의 코어에서 실행됨.

1개의 프로그램을 가리킬 때 보통 1개의 프로세스를 의미함.

컨텍스트 스위칭

CPU는 한 프로그램을 통째로 쭉 실행시키는 게 아니라, 이 프로그램 조금, 저 프로그램 조금씩 골라서 차례를 돌며 실행시킨다.

운영체제의 스케줄러가 프로그램에서 프로그램으로 스위치할 때 "어느 프로그램으로" 스위치할 지 결정하는 역할을 한다.

쓰레드

• 쓰레드: CPU 코어에서 돌아가는 프로그램 단위
• CPU 코어 하나에 한번에 한 개의 쓰레드의 명령을 실행
• 1개의 프로세스는 최소 1개~ 여러 개의 쓰레드로 이루어짐 -> 멀티 쓰레드(multi thread) 프로그램 : 여러개의 쓰레드로 구성된 프로그램

쓰레드와 프로세스의 차이점

프로세스들은 서로 메모리를 공유하지 않음. 프로세스 1, 프로세스 2 중 프로세스1은 프로세스2의 메모리에 접근 불가, 프로세스2도 프로세스 1의 메모리에 접근 불가.

프로세스는 서로의 메모리를 접근 불가, 같은 프로세스 내 쓰레드끼리는 메모리를 공유함. 한 프로세스 내에 쓰레드 1, 쓰레드 2가 있다면 서로 같은 메모리를 공유함.

왜 멀티쓰레드인가?

병렬 가능한(Parallelizable) 작업들

프로그램 논리 구조 상 연산들 간의 의존 관계가 많을수록 병렬화가 어려워지고, 반대로 다른 연산의 결과와 관계없이 독립적으로 수행할 수 있는 구조가 많을수록 병렬화가 매우 쉬워짐.

대기시간이 긴 작업들

예를 들어, 웹사이트를 다운받는 작업을 한다고 치면, 아래와 같이 쓰레드 1개만을 사용할 때와 달리 쓰레드 여러개를 사용할 때가 더 효율적으로 작업을 할 수 있다.

C++에서 쓰레드 생성하기

C++11에서부터 표준에 쓰레드가 추가되면서, 쓰레드 사용이 매우 편리해졌음.

멀티 쓰레드 프로그램을 만들어보자.

// 내 생에 첫 쓰레드
#include <iostream>
#include <thread>

using std::thread;

void func1() {
  for (int i = 0; i < 10; i++) {
    std::cout << "쓰레드 1 작동중! \n";
  }
}
void func2() {
  for (int i = 0; i < 10; i++) {
    std::cout << "쓰레드 2 작동중! \n";
  }
}
void func3() {
  for (int i = 0; i < 10; i++) {
    std::cout << "쓰레드 3 작동중! \n";
  }
}

int main() {
  // 아래와 같이 thread 객체를 생성
  thread t1(func1);
  thread t2(func2);
  thread t3(func3);
  t1.join();
  t2.join();
  t3.join();
}

이때, 결과는 늘 그때마다 다르다는 것을 확인할 수 있다. 프로그램을 실행할 때마다 그 결과가 달라진다는 게 가장 재밌는 점이다. 운영체제가 쓰레드들을 어떤 코어에 할당하고, 또 어떤 순서로 스케줄할 지는 그때그때마다 상황에 맞게 바뀌기 때문에 그 결과를 정확히 예측할 수 없다(주의).

join: 해당하는 쓰레드들이 실행을 종료하면 리턴하는 함수

join과 detach

join되거나 detach되지 않는 쓰레드들의 소멸자가 호출하면 예외를 발생시킴 (main 함수 종료되면 쓰레드 객체들의 소멸자가 호출, 스레드 부르고 join 호출 안하면 예외 발생)

detach

해당 스레드를 실행시킨 후, 잊어버리는 것 (메인함수 종료 후에도 백그라운드에서 실행됨)

쓰레드에 인자 전달하기

쓰레드는 리턴값이란 게 없기 때문에 만약 어떤 결과를 반환하고 싶으면 포인터의 형태로 전달하면 됨.

이때, 컨텍스트 스위치가 되는 그 변수를 출력하고 싶으면 cout 이 아닌 printf 를 사용해야 함 <- 컨텍스트 스위치가 되더라도 다른 쓰레드들이 그 사이에 메세지를 집어넣지 못하게 막기 때문

Callable: 호출할 수 있는 모든 것

람다 함수, 함수 객체 등 역시 callable이라고 할 수 있음.

std::function

callable들을 객체의 형태로 보관할 수 있는 std::function이라는 클래스를 제공함.

#include <functional>
#include <iostream>
#include <string>

int some_func1(const std::string& a) { 
  std::cout << "Func1 호출! " << a << std::endl; 
  return 0;
}

struct S {
void operator()(char c) { std::cout << "Func2 호출! " << c << std::endl; }
};

int main() {
  std::function<int(const std::string&)> f1 = some_func1;
  // std::function<리턴타입(인자타입)> 함수이름 = 진짜함수이름;
  std::function<void(char)> f2 = S();
  std::function<void()> f3 = []() { std::cout << "Func3 호출! " << std::endl; };
  f1("hello");
  f2('c');
  f3();
}

멤버 함수를 가지는 std::function

#include <functional>
#include <iostream>
#include <string>

class A { 
  int c;
public:
  A(int c) : c(c) {}
  int some_func() {
    std::cout << "비상수 함수: " << ++c << std::endl;
    return c;
  }
  int some_const_function() const {
    std::cout << "상수 함수: " << c << std::endl; return c;
  }
  static void st() {} 
};

int main() { 
  A a(5);
  // 원래 인자에 추가적으로 개게를 받는 인자를 전달
  // 상수 함수: 상수 형태로 인자를 받아야 함, 상수 함수가 아니면 단순히 A&로 받으면 됨.
  std::function<int(A&)> f1 = &A::some_func;
  std::function<int(const A&)> f2 = &A::some_const_function;
  f1(a);
  f2(a); 
}

이때 const 함수는 이 함수 안에서는 어떤 변수도 바꿀 수 없음(mutable은 예외)를 뜻한다. 멤버 함수들의 경우 암시적 변환이 발생하지 않으므로 & 연산자를 통해 명시적으로 주소값을 전달해줘야 함..

멤버 함수들을 함수 객체로 - mem_fn

vector들을 가지는 vector가 있을 때, 각각의 vector들의 크기들을 벡터로 만들어주는 코드를 생각해 보자.

#include <algorithm>
#include <functional> 
#include <iostream> 
#include <vector> 

using std::vector;

int main() { 
  vector<int> a(1); 
  vector<int> b(2); 
  vector<int> c(3); 
  vector<int> d(4);

  vector<vector<int>> container; container.push_back(b);
  container.push_back(d);
  container.push_back(a);
  container.push_back(c);

  vector<int> size_vec(4);

  //std::transform(container.begin(), container.end(), size_vec.begin(),
  &vector<int>::size); // 에러 코드
  // std::function<size_t(const vector<int>&)> sz_func = &vector<int>::size;

  transform(container.begin(), container.end(), size_vec.begin(),
std::mem_fn(&vector<int>::size)); // mem_fn으로 사용 가능

  for (auto itr = size_vec.begin(); itr != size_vec.end(); ++itr) {
    std::cout << "벡터 크기 :: " << *itr << std::endl; 
  }
}

function 객체를 리턴해버리는 함수를 추가함 mem_fn은 이름 그대로, 전달된 멤버 함수를 function 객체로 만들어서 리턴해줌.

std::bind

함수 객체 생성 시에 인자를 특정한 것으로 지정할 수 있음.

bind 함수는 원래 함수에 특정 인자를 bind해(붙여) 줌.

#include <functional>
#include <iostream>

void add(int x, int y) {
  std::cout << x << " + " << y << " = " << x + y << std::endl;
}
void subtract(int x, int y) {
  std::cout << x << " - " << y << " = " << x - y << std::endl;
}

int main() {
  auto add_with_2 = std::bind(add, 2, std::placeholders::_1); 
  add_with_2(3);
  // 두 번째 인자는 무시된다. 
  add_with_2(3, 4);

  auto subtract_from_2 = std::bind(subtract, std::placeholders::_1, 2); 
  auto negate =
       std::bind(subtract, std::placeholders::_2, std::placeholders::_1);

  subtract_from_2(3); // 3 - 2 를 계산한다.
  negate(4, 2); // 2 - 4 를 계산한다 
}

이때 bind 인자로 특정 객체를 지정하고 싶다면, 아래와 같이 직접 레퍼런스를 명시적으로 전달해줘야 함. (만약 명시적으로 레퍼런스를 전달하지 않는다면, 복사 생성자가 호출됨)

#include <functional>
#include <iostream>

struct S {
  int data;
  S(int data) : data(data) { std::cout << "일반 생성자 호출!" << std::endl; } 
  S(const S& s) {
    std::cout << "복사 생성자 호출!" << std::endl; data = s.data;
  }
  S(S&& s) {
    std::cout << "이동 생성자 호출!" << std::endl; data = s.data;
  } 
};

void do_something(S& s1, const S& s2) { 
  s1.data = s2.data + 3; 
} 

int main() {
   S s1(1), s2(2);
   std::cout << "Before : " << s1.data << std::endl;
  // s1 이그대로전달된것이아니라s1 의복사본이전달됨! 
   auto do_something_with_s1 =
       std::bind(do_something, std::ref(s1), std::placeholders::_1);
   do_something_with_s1(s2);
   std::cout << "After :: " << s1.data << std::endl;
}

ref 함수는 전달받은 인자를 복사 가능한 레퍼런스로 변환해 주어 s1의 레퍼런스가 잘 전달될 수 있게 함(bind 함수 안으로).

const 레퍼런스의 경우 cref 함수를 호출하면 됨.

C++은 가비지 콜렉터가 없음 -> 한번 획득한 자원은 직접 해제해주지 않는 이상 프로그램이 종료되기 전까지 영원히 남아있게 됨.

예를 들어,

#include <iostream> class A {
  int *data; 
public:
  A() {
    data = new int[100];
    std::cout << "자원을 획득함!" << std::endl;
  }
  ~A() {
    std::cout << "소멸자 호출!" << std::endl; 
    delete[] data;
  } 
};
void do_something() {
  A *pa = new A();
} 

int main() {
   do_something();
  // 할당된 객체가 소멸되지 않음!
  // 즉, 400 바이트(4 * 100) 만큼의메모리누수발생 
}

/* [출력]
자원을 획득함!
*/

자원을 획득만 하고, 소멸자는 호출되지 않음. -> delete *pa를 안해서 생성된 객체의 주소값을 가지는 포인터는 메모리 상에 존재하지 않게 됨.

또한, 아래와 같이 thrower()로 발생된 예외로 delete pa가 실행되지 않고 넘어가면 메모리 누수가 생기게 됨.

void thrower() { 
  // 예외를 발생시킴! 
  throw 1;
}
void do_something() { 
  A *pa = new A(); thrower();
  // 발생된 예외로 인해 delete pa 가 호출되지 않는다!
  delete pa; 
}

Resource Acquisition Is Initialization - RAII

RAII 패턴: 자원의 획득은 초기화다 - * Resource Acquisition Is Initialization *

자원의 관리를 스택에 할당한 객체를 통해 수행하는 것

stack unwinding : 예외가 발생해서 함수를 빠져나가도, 그 함수의 스택에 정의되어 있는 모든 객체들은 빠짐없이 소멸자가 호출된다. -> 예외가 발생하지 않으면 함수가 종료될 때 당연히 소멸자들이 호출됨.

이 개념을 이용해서, 포인터 객체라는 걸 도입하면, 함수가 종료되며 쌓인 객체 스택에서 소멸자들이 차례로 불리면서 포인터 자체와 포인터가 가리키는 객체 자체도 소멸될 수 있다(포인터 객체 내 소멸자에 가리키는 객체를 소멸하는 명령어 존재).

객체의 유일한 소유권 - unique_ptr

C++에서 메모리를 잘못된 방식으로 관리하는 경우 다음 두가지 종류의 문제점이 발생함

• 메모리 사용 후 해제하지 않은 경우: 메모리 누수(memory leak) -> 시스템 메로리가 부족해져서 서버가 죽어버리는 상황이 발생 가능 => RAII 패턴을 사용하면 해결 가능
• 이미 해제된 메모리를 다시 참조하는 경우 -> double free bug: 이미 소멸된 객체를 다시 소멸시켜서 발생하는 버그

2번째 문제점인 double free bug 는 어떤 포인터에 객체의 소유권을 유일하게 부여해서 해결 가능. -> unique_ptr: 특정 객체에 유일한 소유권을 부여하는 포인터 객체

++ unique_ptr로 pa를 스택에 정의된 객체로 만들기 때문에, RAII 패턴 역시 자동 사용 가능.

std::unique_ptr<A> pa(new A());
pa->some();

// 아래와 동일
A* pa = new A();

unique_ptr은 -> 을 오버로드해서 마치 포인터를 다루는 것과 같이 사용할 수 있게 함.

삭제된 함수

#include <iostream>
class A { 
public:
  A(int a){};
  A(const A& a) = delete; 
  // 복사 생성자를 호출하는 부분에서 오류가 발생함
};

int main() {
  A a(3); // 가능
  A b(a); // 불가능 (복사 생성자는 삭제됨)
}

컴파일하게 되면 복사 생성자를 호출하는 부분에서 오류가 발생함. -> 복사 생성자를 명시적으로 삭제했기 때문

이와 같이, unique_ptr도 복사 생성자가 명시적으로 삭제됨. -> unique_ptr는 어떠한 객체를 유일하게 소유해야 하기 때문!

unique_ptr를 복사 생성할 수 있다면, 특정 객체를 여러 unique_ptr들이 소유하게 되는 문제가 발생함. 각각의 unique_ptr들이 소멸될 때 전부 객체를 delete하려고 하기 때문에 double free bug가 발생함.

unique_ptr 소유권 이전하기

소유권은 이전이 가능: 이동 생성자 사용

#include <iostream>
#include <memory>
class A { 
  int *data;
public: 
  A() {
    std::cout << "자원을 획득함!" << std::endl;
    data = new int[100]; 
  }
  void some() { std::cout << "일반 포인터와 동일하게 사용가능!" << std::endl; }
  ~A() {
    std::cout << "자원을 해제함!" << std::endl; delete[] data;
  } 
};

void do_something() {
std::unique_ptr<A> pa(new A());
std::cout << "pa : "; 
pa->some();

// pb 에 소유권을 이전.
std::unique_ptr<A> pb = std::move(pa);
std::cout << "pb : ";
pb->some();

}

int main() { do_something(); }

unique_ptr은 복사 생성자는 정의되어 있지 않지만, 이동 생성자는 가능하다. 마치 소유권을 이동시킨다라는 개념으로 생각하면 됨.

소유권 이동 이후 기존 unique_ptr을 접근하지 않도록 조심해야 함.

unique_ptr를 함수 인자로 전달하기

unique_ptr를 함수 인자로 전달하고 싶다면: unique_ptr는 복사 생성자가 없음. 함수에 레퍼런스로 전달하면?

-> 소유권이라는 의미가 사라지게 됨...

get 함수

void do_something(A* ptr) { ptr->do_sth(3); }

int main() {
  std::unique_ptr<A> pa(new A()); 
  do_something(pa.get());
  // 실제 객체의 주소값을 리턴해 줌: 일반적인 포인터를 받을 수 있음.
}

소유권이라는 의미는 버린 채, do_something 함수 내부에서 객체로 접근 권한을 주는 것.

unique_ptr을 쉽게 생성하기

std::unique_ptr<Foo> ptr(new Foo(3, 5));

unique_ptr로 완벽한 전달을 수행함.

unique_ptr를 원소로 가지는 컨테이너

기본적으로 vector의 push_back 함수는 전달된 인자를 복사해서 집어넣기 때문에 컴파일 때 에러가 발생하게 됨.

#include <iostream>
#include <memory>
#include <vector>

class A { 
  int *data;

public: 
  A(int i) {
    std::cout << "자원을 획득함!" << std::endl; data = new int[100];
    data[0] = i;
  }

  void some() { 
    std::cout << "일반 포인터와 동일하게 사용가능!" << std::endl; 
  }
  ~A() {
    std::cout << "자원을 해제함!" << std::endl; 
    delete[] data;
  } 
};

int main() { 
  std::vector<std::unique_ptr<A>> vec; 
  std::unique_ptr<A> pa(new A(1));
  vec.push_back(pa); // ?? 
}

따라서 아래와 같이 push_back을 사용할 때 move로 명시적으로 이동 생성자 이용!

int main() { 
  std::vector<std::unique_ptr<A>> vec;
  std::unique_ptr<A> pa(new A(1));
  vec.push_back(std::move(pa)); // 잘 실행됨 
}

emplace_back 함수를 이용하면 vector 안에 unique_ptr를 직접 생성해서 넣을 수 있음.

여러 객체가 소유할 수 있는 포인터

특정 자원을 몇 개의 객체에서 가리키는지를 추적한 다음에, 그 수가 0 이 되야만 비로소 해제를 시켜주는 방식의 포인터

shared_ptr

객체를 소유하는 unique_ptr와는 다르게, shared_ptr로 객체로 가리킬 경우, 다른 shared_ptr 역시 그 객체를 가리킬 수 있음.

참조 개수가 0이 되어야 가리키고 있는 객체를 해제할 수 있음.

현재 shared_ptr 의 참조 개수가 몇 개 인지는 use_count 함수를 통해 알 수 있음.

std::shared_ptr<A> p1(new A());
std::shared_ptr<A> p2(p1); // p2 역시 생성된 객체 A 를 가리킨다.

std::cout << p1.use_count(); // 2 
std::cout << p2.use_count(); // 2

개개의 shared_ptr들은 참조 개수가 몇개인 지 알고 있어야 함.

그런데 아래와 같은 경우 p2의 참조 개수는 증가시켜도 p1에 저장된 참조 개수는 건드릴 수 없음.

 std::shared_ptr<A> p3(p2);

-> 이런 문제점 때문에

실제 객체를 가리키는 shared_ptr가 제어 블록(control block)을 동적으로 할당하고 shared_ptr들이 제어 블록에 필요한 정보를 공유하는 방식으로 구현됨.

shared_ptr는 복사 생성할 때마다 해당 제어 블록의 위치만 공유하고, shared_ptr가 소멸할 때마다 제어 블록의 참조 개수를 하나 줄이고, 생성 때마다 하나 늘리는 방식으로 작동함.

생성

std::shared_ptr<A> p1(new A());

위 생성 방법으로는 동적 할당이 2번 발생

• A를 생성하기 위해 동적 할당이 1번 일어나야 함
• 제어 블록을 동적으로 할당함

동적 할당은 아예 두개 합친 크기로 한번 할당하는 게 훨씬 빠름 -> 아래 참고

std::shared_ptr<A> p1 = std::make_shared<A>();

shared_ptr 생성 시 주의할 점

shared_ptr은 인자로 주소값이 전달되면, 마치 본인이 해당 객체를 첫번째로 소유하는 shared_ptr인 것처럼 행동함.

A* a = new A(); 
std::shared_ptr<A> pa1(a); 
std::shared_ptr<A> pa2(a);

따라서 shared_ptr를 주소값을 통해 생성하는 걸 지양해야 함. (이미 해제한 메모리를 또 해제한다는 오류가 날 수 있음)

또한, 순환 참조 문제가 발생할 수 있음(락).

weak_ptr

위에서 말한 순환 참조 문제를 해결하기 위해 weak_ptr를 사용

• 제어블록에는 참조 개수, 약한 참조 개수(weak count)를 기록함
• weak_ptr 활용할 때 lock() 함수를 통해 수행(shared_ptr로 변환해야 함)

복사 생략(Copy Elision)

#include <iostream>

class A {
  int data_;
public:
  A(int data) : data_(data) { std::cout << "일반 생성자 호출!" << std::endl; }
  A(const A& a) : data_(a.data_) {
    std::cout << "복사 생성자 호출!" << std::endl;
  }
};
int main() {
  A a(1); // 일반 생성자 호출
  A b(a); // 복사 생성자 호출
  A c(A(2)); // ❓ 일반 생성자 호출
}

위 코드에서, A c(A(2)); // ❓ 일반 생성자 호출 이 부분의 cpp에서는 복사 생성을 굳이 수행하지 않고, 임시로 만들어진 A(2)를 그냥 2로 취급해 일반 생성자만 호출하게 된다.

좌측값과 우측값

• 좌측값(lvalue): 주소값을 취할 수 있는 값(식의 왼오 모두 올 수 있음)
• 우측값(rvalue): 주소값을 취할 수 없는 값(실체가 없는 값)

좌측값 레퍼런스(lavlue reference)

& 하나를 이용해서 정의하는 레퍼런스 좌측값 레퍼런스 자체도 좌측값이 됨

int& func1(int& a) { return a; }
int func2(int b) { return b; }

int main() {
  int a = 3;
  func1(a) = 4;
  std::cout << &func1(a) << std::endl;
  int b = 2;
  a = func2(b); // 가능
  func2(b) = 5; // 오류 1
  std::cout << &func2(b) << std::endl; // 오류 2
}

func2(b)는 우측값, func1(a)는 좌측값에 해당하게 됨.

우측값 레퍼런스 이용: 이동 생성자

이동 생성자를 이용하면 기존의 메모리에 원소들이 모두 이동됨. 따라서 똑같은 내용으로 메모리를 한번만 차지함(복사 생성자는 두번 차지).

우측값 레퍼런스를 사용한 이동 생성자의 정의 부분은 다음과 같다.

MyString::MyString(MyString&& str) {
  std::cout << "이동 생성자 호출 !" << std::endl;
  string_length = str.string_length;
  string_content = str.string_content;
  memory_capacity = str.memory_capacity;
  // 임시 객체 소멸 시에 메모리를 해제하지
  // 못하게 한다.
  str.string_content = nullptr;
}

우측값의 레퍼런스를 정의하기 위해서 좌측값과는 달리 &를 2개 사용해서 정의해야 함. 여기서 위 생성자의 경우 MyString 타입의 우측값을 인자로 받음. str은 "타입이 <MyString의 우측값 레퍼런스>인 좌측값"이라고 보면 됨. -> 표현식의 좌측에 올 수도 있음.

null ptr 메모리 해제?

우측값 레퍼런스의 예시

int a;
int& l_a = a;
int& ll_a = 3; // 불가능
int&& r_b = 3;
int&& rr_b = a; // 불가능

이동 생성자 작성 시 주의할 점, noexcept

이동 생성 과정에서 예외가 발생하는 경우, 기존의 메모리에 원소들이 모두 이동되어 사라져서 새로 할당한 메모리를 섯불리 해제할 수 없음.

-> vector 및 cpp의 다른 컨테이너들은 이동 생성자가 noexcept가 아닌 이상 이동 생성자를 사용하지 않음.

=> noexcept 추가하면 이동 생성자 사용.

MyString::MyString(MyString &&str) noexcept {
  std::cout << "이동 생성자 호출 !" << std::endl;
  string_length = str.string_length;
  string_content = str.string_content;
  memory_capacity = str.memory_capacity;
  // 임시 객체 소멸 시에 메모리를 해제하지
  // 못하게 한다.
  str.string_content = nullptr;
}

move 문법과 완벽한 전달

좌측값이 우측값으로 취급될 수 있게 바꿔주는 함수: move 함수

move semantics

#include <iostream>
#include <utility>

class A {
public:
  A() { std::cout << "일반 생성자 호출!" << std::endl; }
  A(const A& a) { std::cout << "복사 생성자 호출!" << std::endl; }
  A(A&& a) { std::cout << "이동 생성자 호출!" << std::endl; }
};

int main() {
  A a;  // 일반
  std::cout << "---------" << std::endl;
  A b(a); // 복사
  std::cout << "---------" << std::endl;
  A c(std::move(a)); // 이동
}

std::move 함수가 인자로 받은 객체를 우측값으로 변환해서 리턴해 줌. 실제로는 단순한 타입 변환만 수행함(즉 우측값을 받는 함수들이 오버로딩되며 수행되는 것).

std::move는 이동은 수행하지 않음!

완벽한 전달(perfect forwarding)

#include <iostream>
#include <vector>

template <typename T>
void wrapper(T u) {
  g(u);
}
class A {};

void g(A& a) { std::cout << "좌측값 레퍼런스 호출" << std::endl; }

void g(const A& a) { std::cout << "좌측값 상수 레퍼런스 호출" << std::endl; }

void g(A&& a) { std::cout << "우측값 레퍼런스 호출" << std::endl; }

int main() {
  A a;
  const A ca;
  std::cout << "원본 --------" << std::endl;
  g(a);
  g(ca);
  g(A());
  std::cout << "Wrapper -----" << std::endl;
  wrapper(a);
  wrapper(ca);
  wrapper(A());
}

/*
[출력]
원본 --------
좌측값 레퍼런스 호출
좌측값 상수 레퍼런스 호출
우측값 레퍼런스 호출
Wrapper -----
좌측값 레퍼런스 호출
좌측값 레퍼런스 호출
좌측값 레퍼런스 호출
*/

위와 같이 출력된 이유는 C++ 컴파일러가 템플릿 타입을 추론할 때, 템플릿 인자 R가 레퍼런스가 아닌 일반적인 타입이라면 const를 무시하기 때문이다.

-> 즉, T가 전부 다 class A로 추론됨

따라서 아래와 같이 모든 조합의 템플릿 함수들을 정의해 주면 된다.

template <typename T>
void wrapper(T& u, T& v) {
  g(u, v);
}

template <typename T>
void wrapper(const T& u, T& v) {
  g(u, v);
}

template <typename T>
void wrapper(T& u, const T& v) {
  g(u, v);
}

template <typename T>
void wrapper(const T& u, const T& v) {
  g(u, v);
}

보편적 레퍼런스(Universal reference)

forward 키워드를 사용하면 위에서 거쳤던 복잡한 오버로딩(모든 조합에 대한 오버로딩)을 생략할 수 있음.

#include <iostream>

template <typename T>
void wrapper(T&& u) {
  g(std::forward<T>(u));
}

class A {};

void g(A& a) { std::cout << "좌측값 레퍼런스 호출" << std::endl; }
void g(const A& a) { std::cout << "좌측값 상수 레퍼런스 호출" << std::endl; }
void g(A&& a) { std::cout << "우측값 레퍼런스 호출" << std::endl; }

int main() {
  A a;
  const A ca;
  std::cout << "원본 --------" << std::endl;
  g(a);
  g(ca);
  g(A());
  std::cout << "Wrapper -----" << std::endl;
  wrapper(a);
  wrapper(ca);
  wrapper(A());
}

레퍼런스 겹침 규칙

#include <iostream>

void show_value(int&& t) { 
    std::cout << "우측값 : " << t << std::endl;
}

int main() {
    show_value(5); // 우측값 ok!
    int x = 3;
    show_value(x); // 애러 
}

이때 int&& t는 우측값 외에는 못 받음.

보편적 레퍼런스(Universal reference): 템플릿 인자 T 에 대해서, 우측값 레퍼런스를 받는 형태

기존의 예외 처리 방식(C)

기존에는 아래와 같이 if else문으로 오류 처리를 진행

char *c = (char *)malloc(1000000000);
if (c== null){
  printf("메모리 할당 오류!");
  return;
}

문제점

함수가 쌓이고 딥하게 들어간 함수에서(함수1() -> 함수2() -> 함수3()인데 함수3에서) 예외 처리하는 경우, 함수가 복잡하게 쌓이고, 중간에 다른 요인으로 예외 처리를 하고 싶을 때 그걸 할 수 없다.

throw로 예외 발생시키기

template <typename T>
class Vector {
public:
  Vector(size_t size) : size_(size) {
    data_ = new T[size_];
    for (int i = 0; i < size_; i++) {
      data_[i] = 3;
    }
  }
  const T& at(size_t index) const {
      // 💥여기 주목💥
    if (index >= size_) {
      throw out_of_range("vector 의 index 가 범위를 초과하였습니다.");
    }
    return data_[index];
  }

  ~Vector() { delete[] data_; }
private:
  T* data_;
  size_t size_;

};

throw로 <예외로 전달하고 싶은 객체>를 써주면 된다.

throw한 위치에서 즉시 함수가 종료되고, 예외 처리하는 부분까지 점프함. throw밑 문장은 모두 실행되지 앟음. 함수를 빠져나가며, stack에 생성된 객체들을 빠짐없이 소멸시켜 준다(소멸자만 제대로 작성하면).

예외 처리하기 - try, catch

int main() {
  Vector<int> vec(3);
  int index, data = 0;
  std::cin >> index;
  try {
    data = vec.at(index);
  } catch (std::out_of_range& e) {
    std::cout << "예외 발생 ! " << e.what() << std::endl;
  }
// 예외가 발생하지 않았다면 3을 이 출력되고, 예외가 발생하였다면 원래 data 에
// 들어가 있던 0 이 출력된다.
  std::cout << "읽은 데이터 : " << data << std::endl;
}

이때, out_of_range 클래스는 문자열 필드 하나 달랑 있고 이 역시 what() 함수로 그 값을 들여다 볼 수 있음. 위 경우 vector의 index가 범위를 초과했습니다가 나오게 됨

스택 풀기(stack unwinding)

스택 풀기: catch로 점프하면서 스택 상에서 정의된 객체들을 소멸시키는 과정

throw를 하게 되면 가장 가까운 catch로 점프한다

#include <iostream>
#include <stdexcept>

class Resource {
public:
  Resource(int id) : id_(id) {}
  ~Resource() { std::cout << "리소스 해제 : " << id_ << std::endl; }
private:
  int id_;
};
int func3() {
  Resource r(3);
  throw std::runtime_error("Exception from 3!\n");
}
int func2() {
  Resource r(2);
  func3();
  std::cout << "실행 안됨!" << std::endl;
  return 0;
}
int func1() {
  Resource r(1);
  func2();
  std::cout << "실행 안됨!" << std::endl;
  return 0;
}
int main() {
  try {
    func1();
  } catch (std::exception& e) {
    std::cout << "Exception : " << e.what();
  }
}

생성자에서 예외가 발생할 때 소멸자가 호출되지 않음.

여러 종류의 예외 받기

여러 자료형으로 예외 받기

catch문은 아래와 같이 여러 종류의 자료형으로 받을 수 있음.

catch (char x) {
  std::cout << "Char : " << x << std::endl;
}
catch (int x) {
  std::cout << "Int : " << x << std::endl;
}
catch (std::string& s) {
  std::cout << "String : " << s << std::endl;
}
catch (const char* s) {
  std::cout << "String Literal : " << s << std::endl;
}

기반, 파생 클래스로 예외 받기

예외는 순서대로 들어가므로 func(c)에서 예외로 Child가 발생해도 Patent& p로 예외 처리가 진행된다(첫번쨰 catch문).

#include <exception>
#include <iostream>
class Parent : public std::exception {
public:
  virtual const char* what() const noexcept override { return "Parent!\n"; }
};
class Child : public Parent {
public:
  const char* what() const noexcept override { return "Child!\n"; }
};
int func(int c) {
  if (c == 1) {
    throw Parent();
  } else if (c == 2) {
    throw Child();
  }
  return 0;
}
int main() {
  int c;
  std::cin >> c;
  try {
    func(c);
  } catch (Parent& p) {
    std::cout << "Parent Catch!" << std::endl;
    std::cout << p.what();
  } catch (Child& c) {
    std::cout << "Child Catch!" << std::endl;
    std::cout << c.what();
  }
}

모든 예외 받기

어떤 예외를 throw했는데, 이를 받는 catch가 없으면 catch(...) 쓰면 된다.

try {
  func(c);
} catch (int e) {
  std::cout << "Catch int : " << e << std::endl;
} catch (...) {
// 여기서 try 안에서 발생한 모든 예외들을 받음. 어떤 예외도 다 받을 수 있어서 특정 타입을 찝어 객체에 대입시킬 수는 없음.
  std::cout << "Default Catch!" << std::endl;
}

예외를 발생시키지 않는 함수 - noexcept

어떤 함수가 예외를 안 발생시키면 noexcept를 통해 명시할 수 있음.

int foo() noexcept{}

foo 함수의 경우 예외를 발생시키지 않아 noexcept를 넣어서 나타낼 수 있음. ❗함수에 noexcept 키워드를 붙였다고 해서 함수가 예외를 절대로 던지지 않는 건 아님.

noexcept 붙이는 이유: 컴파일러가 추가적인 최적화를 수행할 수 있음

알고리즘 라이브러리는 컨테이너에 반복자들을 가지고 이런 저런 작업을 쉽게 수행할 수 있도록 도와주는 라이브러리

크게 아래 두 형태를 띄고 있음

template <typeName Iter> void do_something(Iter begin, Iter end); template <typeName Iter, typeName Pred> void do_something(Iter begin, Iter end, Pred pred);

전자: 알고리즘을 수행할 반복자의 시작점과 끝점 바로 뒤를 받음 후자: 반복자는 동일하게 받되, 특정 조건을 추가 인자로 받음(특정 조건: 서술자-Predicate).

Predicate 자리에는 보통 bool 값을 리턴하는 함수 객체(Functor)가 오게 됨.

정렬(sort, stable_sort, partial_sort)

• sort
• stable_sort -> 순서를 지킨 정렬. [a,b]순일 때, a==b인 경우 [a,b]로 순서 지킴 -> sort보다 느림
• partial_sort -> 배열의 일부만 정렬

sort

sort는 기본적으로 오름차순으로 정렬해줌. 내림차순으로 정렬하고 싶으면 아래와 같이 functor를 사용해 비교를 어떻게 수행할 지 알려주면 됨.

#include <algorithm>
#include <iostream>
#include <vector>

template <typename Iter>
void print(Iter begin, Iter end) {
  while (begin != end) {
    std::cout << *begin << " "; begin++;
  }
  std::cout << std::endl;
}

struct int_compare {
  bool operator()(const int& a, const int& b) const { return a > b; }
};

int main() {
  std::vector<int> vec;
  vec.push_back(5);
  vec.push_back(3);
  vec.push_back(1);
  vec.push_back(6);
  vec.push_back(4);
  vec.push_back(7);
  vec.push_back(2);

  std::cout << "정렬 전 ----" << std::endl;
  print(vec.begin(), vec.end());
  std::sort(vec.begin(), vec.end(), int_compare());
  std::cout << "정렬 후 ----" << std::endl;
  print(vec.begin(), vec.end());
}

참고: functional 헤더의 greater<int> 참고

partial_sort

100명의 학생 중 상위 10명 학생의 성적순을 보고 싶다 -> partial sort 사용

시간적 복잡도: O(NlogM)

이때 N개의 원소 중 M개만 순서대로 정렬하고 싶을 때, NlogM 만큼의 시간만큼으로 수행됨. 따라서 모두 다 정렬하는 일반 sort(NlogN) > partial_sort(NlogM) 임

stable_sort

stable_sort가 그냥 sort보다 시간이 더 걸림 최악의 경우 O(n(logn)^2)으로 작동함

원소 제거

remove

원소를 제거하는 함수 remove.

remove 함수는 해당 값 v만을 삭제하도록 돕는 함수로, 원소의 이동만을 수행하지 실제로 원소를 삭제하는 연산을 수행하지는 않음.

remove 함수가 끝나면 해당 값 v들을 뒤로 밀어버리고 밀어진 첫 v값 위치를 가리키는 반복자를 리턴함.

// erase 쓰는 방법
Iterator erase(Iterator first, Iterator last);
// remove 사용해서 erase 쓰기
vec.erase(remove(vec.begin(), vec.end(), 3), vec.end());

remove_if

세번째 인자로 조건을 설명할 함수 객체를 전달받음.

template <typename Iter, typename Pred>
remove_if(Iter first, Iter last, Pred pred)

함수 객체 대신 실제 함수를 전달할 수도 있음 - 아래 참고.

bool odd(const int& i) {
  return i % 2 == 1; 
} 

int main() {
  std::vector<int> vec; 
  vec.push_back(5); 
  vec.push_back(3); 
  vec.push_back(1); 
  vec.push_back(2); 
  vec.push_back(3); 
  vec.push_back(4);
  std::cout << "처음 vec 상태 ------" << std::endl;

  print(vec.begin(), vec.end());
  std::cout << "벡터에서 홀수 인 원소 제거 ---" << std::endl;
  vec.erase(std::remove_if(vec.begin(), vec.end(), odd), vec.end()); 
  print(vec.begin(), vec.end());
}

remove_if에 조건 추가하기

C++ 표준에 따르면, 함수 객체 안에 인스턴스 변수를 넣으면 안됨. <- 해당 함수 객체가 여러번 복사될 수 있기 때문

그렇다면 어떻게 하면 상태가 필요한 조건을 성공적으로 추가할 수 있을까? -> 외부 변수로 빼면 됨: 포인터!

#include <algorithm>
#include <functional>
#include <iostream>
#include <string>
#include <vector>

template <typename Iter>
void print(Iter begin, Iter end) {
  while (begin != end) {
    std::cout << "[" << *begin << "] "; begin++;
  }
  std::cout << std::endl;
 }

struct is_odd { 
  int* num_delete;
  // **포인터로 넘김**
  is_odd(int* num_delete) : num_delete(num_delete) {}
  bool operator()(const int& i) {
    if (*num_delete >= 2) return false; 
    if (i % 2 == 1) {
      (*num_delete)++;
      return true; 
    }
    return false;
  }
};

int main() {
  std::vector<int> vec; 
  vec.push_back(5); 
  vec.push_back(3); 
  vec.push_back(1); 
  vec.push_back(2); 
  vec.push_back(3); 
  vec.push_back(4);
  std::cout << "처음 vec 상태 ------" << std::endl; 
  print(vec.begin(), vec.end());
  std::cout << "벡터에서 홀수인 원소 앞의 2개 제거 ---" << std::endl;
  int num_delete = 0;
  vec.erase(std::remove_if(vec.begin(), vec.end(), is_odd(&num_delete)),
               vec.end());
  print(vec.begin(), vec.end());
}

람다 함수

람다 함수: 이름이 없는 함수 객체

[capture list] (받는 인자) -> 리턴 타입 { 함수 본체 }

// 리턴 타입을 생략할 경우
[capture list] ( 받는 인자) {함수 본체}

문제는 람다 함수 외부에서 정의된 변수들 사용 불가 (나름 함수라서 자기 자신만의 스코프를 가지기 때문)

=> 캡쳐 목록을 사용하면 됨

캡처 목록

어떤 변수를 캡쳐할 지 써주면 됨. 람다 함수 내에서 num_erased를 마치 같은 스코프 안에 있는 것처럼 사용할 수 있게 됨.

int main() { 
  std::vector<int> vec; 

  std::cout << "처음 vec 상태 ------" << std::endl; 
  print(vec.begin(), vec.end());
  std::cout << "벡터에서 홀수인 원소 2개 삭제---" << std::endl; 
  int num_erased = 0; 

  vec.erase(
    std::remove_if(
      vec.begin(),
      vec.end(),
      [&num_erased](int i) {
      // 레퍼런스를 캡처해 와서 람다 함수 스코프 내에서도 변수 내용 바꿀 수 있게 함
        if (num_erased >= 2)
          return false;
        else if (i % 2 == 1) {
          num_erased++;
          return true; 
        }
        return false; 
      }
    ),
    vec.end());
  print(vec.begin(), vec.end());
}

캡쳐 목록 사용법

• [this]: 클래스에서 멤버 함수에서는: this를 캡처 리스트로 전달하는 게 가장 이상적
• []: 아무것도 캡처 안함
• [&a, b]: a는 레퍼런스로 캡처, b는 변경 불가한 복사본으로 캡처
• [&]: 외부 모든 변수들을 레퍼런스로 캡처
• [=]: 외부 모든 변수들을 복사본으로 캡처

원소 수정하기(transform)

transform (시작 반복자, 끝 반복자, 결과를 저장할 컨테이너의 시작 반복자, Pred)

std::cout << "벡터 전체에 1 을 더한다" << std::endl; 
std::transform(vec.begin(), vec.end(), vec.begin(), [](int i) { return i + 1; });

주의

값을 저장하는 컨테이너 크기 >= 원래의 컨테이너

그 외 함수들

find, find_if, any_of, all_of

연관 컨테이너는 키-값 구조를 가짐

키의 존재 유무만 궁금 -> 셋, 멀티셋 키에 대응하는 값이 궁금 -> 맵, 멀티맵

셋

내부적으로 이진 검색 트리 구조로 구성되어 있음. 실제로 셋 내부적으로 원소들이 정렬된 상태를 유지하기 때문!

• 삽입, 삭제: O(logN)
• 검색: O(logN)

즉, 원소를 검색하는데 필요한 횟수는 트리의 높이와 일치. 셋 안에는 중복된 원소들이 없다는 게 또 하나의 특징.

균형 잡힌 트리 구조를 지향 (이진 검색 트리에서 균형잡히지 않은, 편향된 트리 구조를 지양하기 위해 여러 다른 규칙 적용)

커스텀 객체를 셋에 삽입해 보자!

커스텀 객체를 셋에 삽입할 때, < 연산자에 대한 메소드를 명시해야 한다. 셋 내부에서 비교 연산자로 셋에 삽입하기 때문이다.

strict weak ordering

operator <를 설계할 때

1. A < B , B < A 중 하나는 반드시 True여야 함 -> 매몰되기 쉬운 실수!
2. A < A 는 거짓
3. A < B 이고 B < C 이면 A < C
4. A == B 이면 A < B 와 B < A 둘 다 거짓
5. A == B 이고 B == C 이면 A == C

맵

맵의 경우 키에 대응되는 값까지도 같이 보관함

[] 연산자 주의할 점

디폴트 생성자로 0을 만들어서 초기화할 수 있음. 따라서 find()로 있는 지 먼저 확인 후 초기화하는 게 베스트

멀티셋과 멀티맵

멀티셋과 멀티맵은 중복된 원소를 허락 (셋, 맵은 중복 원소 불허)

키로 값 부르기(중복되는 경우)

auto range = m.equal_range(1);

위의 경우 키가 1인 값들을 range에 받아 begin, end를 std::pair로 만들어서 세트로 리턴함.

정렬되지 않은 셋과 맵(unordered_set, unordered_map)

말 그대로 원소들이 정렬되지 않아 있음. 따라서 반복자로 원소들을 하나씩 출력하면 거의 랜덤한 순서로 나옴

실제 unordered_set의 모든 원소들을 반복자로 출력하면 딱히 순서대로 나오지는 않음.

장점

insert, erase, find 모두 O(1)에 수행

-> 상수 시간에 원소 삽입, 검색이 가능

구현 방법 - 해시 함수

해시함수는 1부터 D까지의 값을 반환, 그 해시값을 원소를 저장할 상자의 번호로 삼음. 해시 함수는 구조상 1 ~ D까지 고른 값을 반환하도록 설계함.

같은 원소를 해시 함수에 전달하면 같은 해시값을 리턴. -> 원소의 탐색을 빠르게 수행

=> 그러나, 해시 충돌의 경우와 rehash의 경우, 최악의 경우 O(n)이 될 수 있음.

보통의 경우 안전하게 맵, 셋을 이용 만약 최적화가 매우 필요한 작업일 경우: 해시 함수, 상자 개수를 잘 설계해서 unordered_set, unordered_map을 사용하는 게 좋음.

커스텀 객체에 해시 함수 반영

functor를 사용해보자(객체이지만 함수인 척을 하는 객체).

class Todo {
  int priority; // 중요도. 높을 수록 급한것! std::string job_desc;
public:
  Todo(int priority, std::string job_desc)
        : priority(priority), job_desc(job_desc) {}
  bool operator==(const Todo& t) const {
      // **!! 해시 충돌 발생 시 상자 안 원소들과 비교해야 하기 때문**
    if (priority == t.priority && job_desc == t.job_desc)
      return true; return false;
  }
  friend std::ostream& operator<<(std::ostream& o, const Todo& t);
  friend struct std::hash<Todo>; 
};

// Todo 해시 함수를 위한 함수객체(Functor) // 를 만들어줍니다!
namespace std {
  template <>
  struct hash<Todo> {
    size_t operator()(const Todo& t) const {
      hash<string> hash_func;
      return t.priority ^ (hash_func(t.job_desc));
    } 
  };
} // namespace std

return문 -> priority는 int값(해시값 그 자체로 쓰기로 함), string의 해시값은 hash_func 객체로 이용해서 계산, 이를 XOR시킴.

namespace문 -> 특정 namespace 안에 새로운 클래스/함수 추가 위해서는 위처럼 명시적으로 namespace를 써줘야 하기 때문(여기 참고)