choi_612.log

[Network]OSI 7 layer

Tue, 07 Mar 2023 09:53:39 GMT

OSI 7 계층

네트워크 7계층

OSI 7 layer Open Systems Interconnection Reference Model

컴퓨터 네트워크 프로토콜 디자인과 통신을 7계층으로 나눠 정리 즉 네트워크에서 통신이 일어나는 과정을 7단계로 정리

OSI 7 Layer 7 Application Layer 최상위 계층으로 사용자가 직접 이용할 수 있는 형태로 제공된다. 6 Presentation Layer 데이터의 형태를 압축, 암호화, 복호화를 한다. 5 Session Layer – 하위계층과 상위계층과의 연결(데이터와 서비스). 4 Transport Layer 데이터 분할(segment), TCP인 경우엔 오류확인&전송확인이 불가할 때 재전송한다(오류제어). 3 Network Layer 논리적 주소(IP Address)를 기반으로 경로를 설정한다(Routing). 2 Datalink Layer 물리적 주소(MAC Address)를 기반으로 데이터 전송형태를 설정하며, Tail이라는 꼬리로 데이터 이상유무를 확인한다. Encoding을 실시한다. 1 Physical Layer 전기적 신호로 실제 전송

2.데이터의 전송 데이터는 캡슐화 라는 절차를 거쳐 상대방에게 전송된다. 데이터는 각 계층을 지날 때마다 데이터의 맨 앞에 헤더가 붙게 되고, 추가된 헤더는 다음 계층에서 하나의 데이터로 취급받게 된다. 상위 계층에서 하위계층으로 캡슐화 되는 것을 encapsulation, 하위 계층에서 상위계층으로 역 캡슐화 De-encapsulation 이라고 한다.

3.De-capsulation과 encapsulation의 차이점 1.Datalink Layer 물리적 주소와 다른 데이터는 Drop, 자기 주소와 일치되는 데이터만 상위 계층으로 올린다. 수신된 데이터의 용량이 Tail용량과 다를 경우에 재전송을 요청한다. 2.Network Layer 논리적 주소와 다른 데이터는 Drop, 자기 주소와 일치하는 데이터만 상위로 올린다.

[CS] OS byte order

Tue, 10 Jan 2023 06:54:38 GMT

{참고자료} Endian bit order LSB/MSB 비트연산자 비트 마스크 비트 마스킹

byte / bit

컴퓨터는 모든 데이터를 2진수로 처리

bit

data 최소 단위 2진수값인 '0', '1' 두 값 중 하나로 저장

byte

문자 표현이 가능한 최소 단위 8bits = 1 byte 0x00 ~ 0xFF 0b00000000~0b11111111

[C++/C] 진수 표기법

10진수 (data) 2진수는 0b(data) 8진수는 0(data) 16진수는 0x(data)

int a = 100;        // 10진수로 표현한 100
    int b = 0b01100100;    // 2진수로 표현한 100
    int c = 0144;    // 8진수로 표현한 100
    int d = 0x64;    // 16진수로 표현한 100

bit - MSB / LSB

MSB

Most Significant bit 최상위 비트

signed / unsigned data 따라 정보가 달라짐

LSB

Least Significant bit 최하위 비트

데이터의 홀짝 / 난수발생 함수, 해시 함수, checksum 확인

bit

2진수의 최상위 최하위 bit를 파악 하나의 데이터에서 처음과 끝 및 방향 파악 MBS < ---- LSB

serial 통신시 송수신의 방향 유의

byte order

컴퓨터 메모리에 바이트가 저장 되는 순서

Big Endian 빅엔디안

낮은 주소에 MSB 부터 저장

32bit 0x12345678 byte로 저장시 0x12 0x34 0x56 0x78 로 저장

Little Endian 리틀엔디안

낮은 주소에 LSB 부터 저장

32bit 0x12345678 byte로 저장시 0x78 0x56 0x34 0x12 로 저장

대부분의 인텔 CPU 계열에서 사용

내가 어려웠던 것

byte order 저장 방식을 읽는 것 메모리에는 Little Endian로 저장 하지만 읽어올때는 사람이 읽는 방향과 같다 memcyp시 packet 값을 낮은 주소에 LSB로 저장 0x3DB 값의 4 bytes packet DB 03 00 00 data 가공시 유의 필요 > 1byte씩 처리 또는 bit operation으로 가공
읽어 오는 packet 크기에 따라 data 값이 변경됨 packet 값 32bits 00 00 AA AA

32bits로 읽어오면 Little endian 0xAAAA0000 Big endian 0x0000AAAA

하지만 16bit로 뒤에만 읽어오면 둘다 0xAAAA로 같다

packet 값 16 bits 12 34

16bits로 읽어오면 Little endian 0x3412 Big endian 0x1234

Packet에 보이는 data 그대로 값이 아니라 OS rule에 따라 packet 값이 다를게 확인 될 수 있음 구현시 주의 할 것.

bitwise operator

비트 연산자 [C++/C 기반]

기본 연산자

연산자	연산기능
&	비트 단위 AND연산
\|	비트 단위 OR연산
^	비트 단위 XOR연산
~	단항 연산자 모든 피연사자 비트 반전

^연산자

두 개의 비트가 서로 다른 경우에 1을 반환

연산	결과
0 ^ 0	0
0 ^ 1	1
1 ^ 0	1
1 ^ 1	0

~연산자

0에서 1로, 1에서 0으로 반전시키는 NOT 연산/ 보수연산 signed의 경우 MSB가 반전되어 부호가 바뀜 주의

 int num1 = 15; //00000000 00000000 00000000 00001111
 int num2 = ~num1; // 11111111 11111111 11111111 11110000

Shift

left shift <<

비트를 왼쪽으로 이동 남은 자리는 0으로 채움 A * 2^B 연산과 동일 A << B A의 비트 열을 B칸씩 왼쪽으로 이동 범위값을 넘어가면 값이 사라짐 주의

uint8_t num = 3; //0000 0011 
uint8_t shift num = num << 4; // 0011 0000

right shift >>

비트를 오른쪽으로 이동 남은 자리는 0으로 채움 A / 2^B 연산과 동일 A >> B A의 비트 열을 B칸씩 오른쪽으로 이동 범위값을 넘어가면 값이 사라짐 주의

uint8_t num = 7; //0000 0111 
uint8_t shift num = num >> 2; // 0000 0001

Shift 연산은 범위값에 아주 유의 하여야한다

bit mask

비트를 바스킹 하는 기법

모든비트 0

int num = 0 //00000000 00000000 00000000 00000000

모든비트 1

int num = -1 //11111111 11111111 111111111

특정 비트 삭제 특정위치만 0 나머지 1 후 and 연산 해주기
특정 비트만 포함 시키기 특정 위치만 1 나머지 0 후 or 연산 해주기
특정 비트 포함 여부 확인 해당 위치만 1 나머지 0 후 and 연산 해주기
특정 비트 토글 해당 위치만 1하여 XOR 연산 수행하기

토글 하나의 설정 값으로부터 다른 값으로 전환 1>0, 0>1 7. 마지막 비트 구하기 보수 체계 이용 num과 -num의 and 연산 수행 8. 마지막 비트 삭제 하기 보수 체계 이용 num과 num-1의 and 연산 수행

data type

자료형 [C++/C 기반]

기본 자료형

크기가 표시된 정수 자료형을 사용하면 bit 계산시 유용하다 data를 원하는 만큼만 잘라서 사용하기 용이

int main( void ) 
{
   int8_t a;
   int16_t b;
   int32_t c;
   int64_t d;

   uint8_t e;
   uint16_t f;
   uint32_t g;
   uint64_t h; 
}

Signed / unsigned 의 차이로 음수를 적용하는 지 파악 > unsigned의 경우 2의 보수 이용이 안된다.

bool은 실제로 1bit지만 1byte만큼 차지 한다

data 값이 U를 붙이면 unsigned인 값이 된다

uint8_t a = 10U;

unsigned long a = 0UL;

0   // normal number is interpreted as int
0L  // ending with 'L' makes it a long
0LL // ending with 'LL' makes it long long
0UL // unsigned long

0.0  // decimal point makes it a double
0.0f // 'f' makes it a float

C++ Thread (2)

Mon, 11 Jul 2022 07:26:47 GMT

*씹어먹는 C++ *

16장 C++ 쓰레드 766p-825p

컴퓨터 구조

메모리 memory

CPU <-> RAM(메모리) 물리적 거리로 인해 데이터를 읽어 오는데 시간이 걸림

캐시 Cache

cpu 칩 안에 있는 작은 메모리 RAM과는 다르게 연산을 하는 부분과 붙어있어 읽기와 쓰기 속도가 빠름 CPU가 특정한 주소에 있는 데이터에 접근 시, 일단 캐시에 있는지 확인, 있다면 해당 값을 읽고, 없다면 메모리 까지 갔다 오는 방식으로 진행

Cache hit 캐시에 있는 데이터를 다시 요청해서 시간을 절약
Cache miss 캐시에 요청한 데이터가 없어서 메모리 까지 갔다 오는 것
CPU에서 캐시 작동 방식 메모리를 읽으면 일단 캐시에 저장 만일 캐시가 다 찼다면 특정한 방식에 따라 처리
- LRU(Least Recently Used) 캐시를 날려버리고 그 자리에 새로운 캐시를 기록하는 방식 최근에 접근한 데이터를 자주 반복해서 접근한다면 매우 유리

CPU 파이프라이닝(pipelining)

파이프라이닝(pipelining) 작업이 끝나기 전에, 다음 작업을 시작하는 방식으로 동시에 여러 개의 작업을 동시에 실행하는 것

CPU 에서 명령어를 실행할 때 여러 단계를 거침

명령어를 읽어야 하고 (fetch), 읽은 명령어가 무엇 인지 해석해야 하고 (decode), 해석된 명령어를 실행하고(execute), 마지막으로 결과를 써야함 (write).

컴파일러는 최대한 CPU 의 파이프라인을 효율적으로 활용할 수 있도록 명령어 재배치

수정 순서(modification order)

C++ 의 모든 객체들이 정의 가능 원자적 연산을 할 경우에 모든 쓰레드에서 같은 객체에 대해서 동일한 수정 순서 관찰 가능 순서 동일 -> 수정 순서가 바뀌지 않는 것을 보장

따라서 명령어 재배치를 한다해도 모든 쓰레드에서 변수의 수정 순서에 동의만 한다면 문제될 것이 없음

원자성(atomicity)

원자처럼 쪼갤 수 없다

모든 연산들이 원자적일때 C++ 에서 모든 쓰레드들이 수정 순서에 동의해야만 함

원자적 연산

CPU 가 명령어 1 개로 처리하는 명령 중간에 다른 쓰레드가 끼어들 여지가 전혀 없는 연산 원자적 연산들은 올바른 연산을 위해 굳이 뮤텍스가 필요하지 않음 -> 연산 속도가 더 빠르다

c++에서 몇몇 타입들에 원자적인 연산을 쉽게 할 수 있도록 여러가지 도구들을 지원

atomic

std::atomic counter(0); atomic 의 템플릿 인자로 원자적으로 만들고 싶은 타입을 전달 atomic 객체에서 제공하는 함수들을 통해서, 여러가지 원자 적인 연산들을 손쉽게 수행

example code

#include 
#include 
#include 
#include 

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

int main() {
  std::atomic counter(0);

  std::vector 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;

Counter 최종 값 : 40000

CPU는 원래 한 명령어에서 메모리에 읽기 혹은 쓰기 둘 중 하나 밖에 못함

그러나 Assembly Language lock add DWORD PTR [rdi], 1 lock add 명령어를 통해 rdi 에 위치한 메모리를 읽고 - 1 더하고 - 다시 rdi 에 위치한 메모리에 쓰기를 모두 함.

해당 명령어를 컴파일러가 사용 가능 이유 어느 CPU 에서 실행할 지(x8) 컴파일러가 알고 있기 때문에 이런 CPU 특이적인 명령어를 제공 가능함. CPU에 따라 해당 명령이 없는 경우도 있음
is_lock_free() 함수 lock free 에서의 lock 이 없다 의미 뮤텍스와 같은 객체들의 lock, unlock 없이도 해당 연산을 올바르게 수행할 수 있다는 뜻
```
std::atomic x;
std::cout << "is lock free ? : " << boolalpha << x.is_lock_free() << std::endl;
```
Is lock free ? : true

memory_order

막기 위해서 메모리 재배치 순서를 강제를 위해 C++에서 제공 atomic 객체들의 경우 원자적 연산 시에 메모리에 접근할 때 어떠한 방식으로 접근하는지 지정 가능

memory_order_relexed

메모리에서 읽거나 쓸 경우, 주위의 다른 메모리 접근들과 순서가 바뀌어도 무방 메모리 연산들사이에서 어떠한 제약조건도 없음 서로 다른 변수의 relaxed 메모리 단일 쓰레드 관점에서 결과가 동일하다면 연산은 CPU 마음대로 재배치 가능 -> CPU에서 매우 빠른 속도로 실행 가능

relaxed 메모리 연산을 사용하면 예상치 못한 결과가 나올 수 있으니 주의 필요.

#include 
#include 
#include 
#include 
using std::memory_order_relaxed;

void t1(std::atomic* a, std::atomic* 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* a, std::atomic* 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 threads;

  std::atomic a(0);
  std::atomic 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();
  }
}

x : 1 y : 0

x : 0 y : 1

x : 1 y : 1

store & load atomic 객체들에 대해서 원자적으로 쓰기와 읽기를 지원해주는 함수

memory_order_acquire 과 memory_order_release

두 개의 다른 쓰레드들이 같은 변수의 release 와 acquire 를 통해서 동기화 (synchronize)를 수행

memory_order_release

해당 명령 이전의 모든 메모리 명령들이 해당 명령 이후로 재배치 되는 것을 금지

memory_order_acquire

release 와는 반대로 해당 명령 뒤에 오는 모든 메모리 명령들이 해당 명령 위로 재배치 되는 것을 금지

example code

#include 
#include 
#include 
#include 
using std::memory_order_relaxed;

std::atomic is_ready;
std::atomic data[3];

void producer() {
  //store시에는 relaxed라서 재배치 가능하나
  data[0].store(1, memory_order_relaxed);
  data[1].store(2, memory_order_relaxed);
  data[2].store(3, memory_order_relaxed);

  // 아래 release 명령어를 넘어서 재배치는 안된다. 
  is_ready.store(true, std::memory_order_release);
}

void consumer() {
  // data 가 준비될 때 까지 기다린다.
  while (!is_ready.load(std::memory_order_acquire)) {
  }

  std::cout << "data[0] : " << data[0].load(memory_order_relaxed) << std::endl;
  std::cout << "data[1] : " << data[1].load(memory_order_relaxed) << std::endl;
  std::cout << "data[2] : " << data[2].load(memory_order_relaxed) << std::endl;
}

int main() {
  std::vector threads;

  threads.push_back(std::thread(producer));
  threads.push_back(std::thread(consumer));

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

data[0] : 1 data[1] : 2 data[2] : 3

memory_order_acq_rel

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

memory_order_seq_cst

메모리 명령의 순차적 일관성(sequential consistency) 을 보장 순차적 일관성을 보장하기 위해서는 CPU 의 동기화 비용이 매우 큼 따라서 해당 명령은 정말 꼭 필요 할 때만 사용

순차적 일관성 메모리 명령 재배치도 없고, 모든 쓰레드에서 모든 시점에 동일한 값을 관찰 가능 함

atomic 의 메모리 memory_order 지정 연산 정리

연산	허용된 memory order
쓰기 (store)	memory_order_relaxed, memory_-order_release, memory_order_seq_-cst
읽기 (load)	memory_order_relaxed, memory_-order_consume, memory_order_-acquire, memory_order_seq_cst
읽고 - 수정하고 - 쓰기 (read - modify - write)	memory_order_relaxed, memory_-order_consume, memory_order_-acquire, memory_order_release, memory_order_acq_rel, memory_-order_seq_cst

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

C++ 에서 제공하는 promise, future, packaged_task, async 를 잘 활용하면 귀찮게 mutex 나 condition_variable 을 사용하지 않고도 매우 편리하게 비동기적 작업을 수행

동기적 (synchronous)실행

한 번에 하나씩 순차적으로 실행 되는 작업되도록 실행 동기적인 작업들은 한 작업이 끝날 때 까지 다음 작업으로 이동하지 않기 때문

비동기적(asynchronous) 실행

프로그램의 실행이, 한 갈래가 아니라 여러 갈래로 갈라져서 동시에 진행 어떠한 데이터를 다른 쓰레드를 통해 처리해서 받아내도록 실행 C++ 의 경우 위와 같이 명시적으로 쓰레드를 생성해서 적절히 수행하여 사용할 수 있도록 함

std::promise 와 std::future

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

생산자-소비자 패턴에서 promise 는 생산자 (producer) 의 역할을 수행하고, future 는 소비자 (consumer) 의 역할을 수행

해당 패턴은 조건 변수로도 구현이 가능하나 더 복잡하다. 또한 조건 변수와는 다르게 예외 전달도 가능.

promise 객체 연산을 수행 후에 돌려줄 객체의 타입을 템플릿 인자로 받음 연산이 끝난 다음에 promise 객체는 자신이 가지고 있는 future 객체에 값을 넣어줌.
future 객체 promise 가 future 에 값을 전달하기 전까지 wait으로 대기 get 함수를 바로 호출하더라도 알아서 promise 가 future 에 객체를 전달할 때 까지 기다린 다음에 리턴
future 에서 get 을 호출하면, 설정된 객체가 이동 따라서 절대로 get 을 두 번 호출하면 안됩니다.

example code

#include 
#include 
#include 
#include 
using std::string;

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

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

  std::thread t(worker, &p);

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

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

  t.join();
}

받은 데이터 : some data

wait_for

정해진 시간 동안만 기다리고 그냥 진행 가능 promise 가 설정될 때 까지 기다리는 대신에 wait_for 에 전달된 시간 만큼 기다렸다가 바로 리턴 리턴하는 값은 현재 future 의 상태를 나타내는 future_status 객체 3가지

future_status
1. future_status::ready
  1. future_status::timeout wait_for 에 지정한 시간이 지났지만 값이 설정되지 않아서 리턴
2. future_status::deferred 결과값을 계산하는 함수가 채 실행되지 않았다는 의미

shared_future

여러 개의 다른 쓰레드에서 future를 get 할 필요성이 있을때 사용

condition_variable를 사용하서 구현 가능하나 future가 편리

shared_future 의 경우 future 와는 다르게 복사가 가능 복사본들이 모두 같은 객체를 공유 따라서 레퍼런스나 포인터로 전달할 필요가 없음

example code

#include 
#include 
#include 
#include 
using std::thread;

void runner(std::shared_future start) {
  start.get();
  std::cout << "출발!" << std::endl;
}

int main() {
  std::promise p;
  std::shared_future start = p.get_future();

  thread t1(runner, start);
  thread t2(runner, start);
  thread t3(runner, start);
  thread t4(runner, start);

  // 참고로 cerr 는 std::cout 과는 다르게 버퍼를 사용하지 않기 때문에 터미널에
  // 바로 출력된다.
  std::cerr << "준비...";
  std::this_thread::sleep_for(std::chrono::seconds(1));
  std::cerr << "땅!" << std::endl;

  p.set_value();

  t1.join();
  t2.join();
  t3.join();
  t4.join();
}

준비...땅! 출발! 출발! 출발! 출발!

packaged_task

C++에서 지원 비동기적 함수(정확히는 Callable - 즉 람다 함수, Functor 포함) 의 리턴값에 간단히 적용

packaged_task 에 전달된 함수가 리턴할 때, 그 리턴값을 promise 에 set_value 하고, 만약에 예외를 던졌다면 promise 에 set_exception

해당 future 는 packaged_task 가 리턴하는 future 에서 접근 가능

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

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

쓰레드에 굳이 promise 를 전달하지 않아도 알아서 packaged_task 가 함수의 리턴값을 처리해줘서 매우 편리

example code

#include 
#include 
#include 

int some_task(int x) { return 10 + x; }

int main() {
  // int(int) : int 를 리턴하고 인자로 int 를 받는 함수. (std::function 참조)
  std::packaged_task task(some_task);

  //해당 promise 에 대응되는 future 는 위와 같이 get_future 함수로 받음
  std::future start = task.get_future();

  std::thread t(std::move(task), 5);

  std::cout << "결과값 : " << start.get() << std::endl;
  t.join();
}

결과값 : 15

std::async

비동기적으로 실행을 하기 위해서는, 쓰레드를 명시적으로 생성해서 실행하는 promise 나 packaged_task과 다르게

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

첫번째 인자 std::launch::async :
```
바로 쓰레드를 생성해서 인자로 전달된 함수를 실행
```
std::launch::deferred :
```
future 의 get 함수가 호출되었을 때 실행 (새로운 쓰레드를 생성하지 않음)
```
해당 함수를 굳이 바로 당장 비동기적으로 실행할 필요가 없다면 deferred 옵션 선택

실행하는 함수의 결과값을 포함하는 future 를 리턴

example code

#include 
#include 
#include 
#include 

// std::accumulate 와 동일
int sum(const std::vector& v, int start, int end) {
  int total = 0;
  for (int i = start; i < end; ++i) {
    total += v[i];
  }
  return total;
}

int parallel_sum(const std::vector& v) {
  // lower_half_future 는 1 ~ 500 까지 비동기적으로 더함
  // 참고로 람다 함수를 사용하면 좀 더 깔끔하게 표현할 수 도 있다.
  // --> std::async([&v]() { return sum(v, 0, v.size() / 2); });
  std::future lower_half_future =
    std::async(std::launch::async, sum, cref(v), 0, v.size() / 2);

  // upper_half 는 501 부터 1000 까지 더함
  int upper_half = sum(v, v.size() / 2, v.size());

  return lower_half_future.get() + upper_half;
}

int main() {
  std::vector v;
  v.reserve(1000);

  for (int i = 0; i < 1000; ++i) {
    v.push_back(i + 1);
  }

  std::cout << "1 부터 1000 까지의 합 : " << parallel_sum(v) << std::endl;
}

1 부터 1000 까지의 합 : 500500

C++ Thread

Wed, 06 Jul 2022 05:44:52 GMT

*씹어먹는 C++ *

16장 C++ 쓰레드 719p-825p

운영체제

프로세스 운영체제에서 실행되는 프로그램의 최소 단위 CPU 코어에서 실행
스케줄러 scheduler 여러 프로세스를 돌리기 위해 컨텍스트 스위칭 어떤 프로그램을 실행시키고, 얼마 동안 실행 시키고, 스위치 시킬지 결정

쓰레드

CPU 코어에서 돌아가는 프로그램 단위 CPU 의 코어 하나에서는 한 번에 한 개의 쓰레드의 명령을 실행 한 개의 프로세스는 최소 한 개 쓰레드로 이루어져 있으며, 여러 개의 쓰레드로 구성도 가능

쓰레드와 프로세스의 가장 큰 차이점 프로세스는 서로의 메모리를 접근할 수 없음
그러나* 같은 프로세스 내에 쓰레드 끼리는 메모리를 공유

멀티 쓰레드 (multithread) 프로그램

여러개의 쓰레드로 구성된 프로그램

병렬화(parallelize) 어떠한 작업을 여러개의 다른 쓰레드를 이용해서 좀 더 빠르게 수행 가능 불가능 한 경우도 있다 ex) 피보나치 수열 연산들 간의 의존 관계가 많을 수로 병렬화 힘듦 다른 연산의 결과와 관계 없이 독립적으로 수행시 병렬화 쉬움
- A가 B에 의존(dependent) 어떠한 연산 (연산 A) 을 수행하기 위해 다른 연산 (연산 B)의 결과가 필요
대기시간이 긴 작업 CPU 시간을 낭비하지 않고 효율적 작업 처리 가능

C++ Thread

example code

//헤더 파일 

#include 
#include 
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();
  //or t1.detach();
}

랜덤하게 쓰레드 # 작동중!이 출력됨

운영체제 스케줄링에 따라 다름 랜덤하게 각 쓰레드 실행

운영체제가 쓰레드들을 어떤코어에 할당하고, 또 어떤 순서로 스케쥴 할지는 그 때 그 때 마다 상황에 맞게 바뀌기 때문에 그 결과를 정확히 예측할 수 없음.

join() 해당하는 쓰레드들이 실행을 종료하면 리턴하는 함수 t1 이 종료하기 전 까지 리턴하지 않음.
사용하지 않으면 쓰레드들의 내용이 실행되기전에 main 함수가 종료되어서 쓰레드 객체들 (t1, t2, t3)의 소멸자가 호출됨
join 되거나 detach 되지 않는 쓰레드들의 소멸자가 호출시엔 예외 발생
detach() main은 종료되고 쓰레드는 알아서 백그라운드에서 돌아감.

쓰레드에 인자 전달

포인터의 형태로 전달 리턴 값이 없기 때문.

#include 
#include 
#include 
#include 
using std::thread;
using std::vector;

void worker(vector::iterator start, vector::iterator end, int* result) {
  int sum = 0;
  for (auto itr = start; itr < end; ++itr) {
      sum += *itr;
  }
  *result = sum;

  // 쓰레드의 id 를 구한다.
  thread::id this_id = std::this_thread::get_id();
  printf("쓰레드 %x 에서 %d 부터 %d 까지 계산한 결과 : %d \n", this_id, *start,*(end - 1), sum);
}
int main() {
  vector data(10000);
  for (int i = 0; i < 10000; i++) {
      data[i] = i;
  }

  // 각 쓰레드에서 계산된 부분 합들을 저장하는 벡터
  vector partial_sums(4);

  vector workers;
  for (int i = 0; i < 4; i++) {
  workers.push_back(thread(worker, data.begin() + i * 2500, data.begin() + (i + 1) * 2500, &partial_sums[i]));
  }

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

  int total = 0;
  for (int i = 0; i < 4; i++) {
      total += partial_sums[i];
  }
  std::cout << "전체 합 : " << total << std::endl;
}

쓰레드 a754700 에서 0 부터 2499 까지 계산한 결과 : 3123750 쓰레드 9752700 에서 5000 부터 7499 까지 계산한 결과 : 15623750 쓰레드 9f53700 에서 2500 부터 4999 까지 계산한 결과 : 9373750 쓰레드 8f51700 에서 7500 부터 9999 까지 계산한 결과 : 21873750 전체 합 : 49995000

printf / cout

printf "..." 안에 있는 문자열을 출력할 때, 컨텍스트 스위치가 되더라도 다른 쓰레드들이 그 사이에 메세지를 집어넣지 못하게 막음

하지만

cout << 사이 제외하고 전체 한줄이 출력되는 동안 중간에 다른 쓰레드가 출력하지 못하게 막는 것이 보장 안됨

쓰레드로 메모리 동시 접근 시 주의

경쟁 상태 (race condtion) 서로 다른 쓰레드에서 같은 메모리를 공유할 때 발생할 수 있는 문제
CPU 연산 처리 CPU 의 레지스터(register)에 데이터를 기록한 다음에 연산 수행
모든 데이터들은 메모리에 저장되어 있고, 연산 할 때 할 때 마다 메모리에서 레지스터로 값을가져온 뒤에, 빠르게 연산을 하고, 다시 메모리에 가져다 놓는 식으로 작동

스케줄러에 따라 다르게 쓰레드가 실행되므로 멀티 쓰레드 프로그램의 경우 프로그램 실행 마다 그 결과가 달라질 수 있습니다. 이게 무슨 말일까요? 제대로 프로그램을 만들지 않았을 경우 디버깅이 겁나 어렵다는 뜻입니다. ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

뮤텍스 (metex)

mutex 영어의 상호 배제 (mutual exclusion)

한번에 한 쓰레드만 해당 메모리 접근을 시키기 위해 사용

한번에 한 쓰레드에서만 m 의 사용 권한 갖음 m.lock() 시 해당 뮤텍스 m 사용 권한을 갖는다 m.unlock() 시 m을 반환 만약 사용시 m.lock을 하면 무한정 대기

임계 영역(critical section) m.lock() 과 m.unlock() 사이에 한 쓰레드만이 유일하게 실행할 수 있는 코드 부분
lock_guard 뮤텍스를 인자로 받아서 생성하게 되는데, 이 때 생성자에서 뮤텍스를 lock 그리고 lock_guard 가 소멸될 때 알아서 lock 했던 뮤텍스를 unlock

example code

#include 
#include  // mutex 를 사용하기 위해 필요
#include 
#include 

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 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;
}

Counter 최종 값 : 40000

데드락(deadlock)

결국 아무 쓰레드도 연산을 진행하지 못하게 되는 상황 방지 하기 위해 취득한 뮤텍스는 사용이 끝나면 반드시 반환 할 것. 소멸자에서 처리 가능(lock_guard 나 unique_lock 등을 이용)

void worker1(std::mutex& m1, std::mutex& m2) {
  for (int i = 0; i < 10000; i++) {
    std::lock_guard lock1(m1);
    std::lock_guard lock2(m2);
    // Do something
  }
}
void worker2(std::mutex& m1, std::mutex& m2) {
  for (int i = 0; i < 10000; i++) {
    std::lock_guard lock2(m2);
    std::lock_guard lock1(m1);
    // Do something
  }
}

worker1 에서 m2 를 lock 하기 위해서는 worker2 에서 m2 를 unlock 해야함. 하지만 그러기 위해서는 worker2 에서 m1 을 lock 해야 함. 그런데 이 역시 불가능. 왜냐하면 worker1 에 m1 을 lock 하고 있기 때문. worker1 과 worker2 모두 이러지도 저러지도 못하는 데드락 상황.

해결 방법

우선권 한 쓰레드에게 우선권을 갖도록 할 수 있으나 기아 상태 발생 할 수 있음
```
  - 기아 상태(starvation)
```
한 쓰레드가 다른 쓰레드에 비해 우위를 갖게 된다면, 한 쓰레드만 열심히 일하고 다른 쓰레드는 일할 수 없는 상태
```
  - try_lock
  이 함수는 만일 m1 을 lock 할 수 있다면 lock 을 하고 true 를 리턴
  lock 을 할 수 없다면 기다리지 않고 그냥 false 를 리턴
```
중첩된 Lock 을 사용하는 것을 피해라
Lock 을 소유하고 있을 때 유저 코드를 호출하는 것을 피해라
Lock 들을 언제나 정해진 순서로 획득해라

생산자(Producer) 와 소비자(Consumer) 패턴

생산자 무언가 처리할 일을 받아오는 쓰레드를 의미
소비자 받은 일을 처리하는 쓰레드를 의미

example code

#include   // std::chrono::miliseconds
#include 
#include 
#include 
#include 
#include 
#include 

void producer(std::queue* 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* 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 downloaded_pages;
  std::mutex m;

  std::vector 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 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 쓰레드 웹사이트에서 페이지를 계속 다운로드 하는 역할 다운로드한 페이지들을 downloaded_pages 라는 큐에 저장
FIFO 특성을 이용하기 위해서
consumer 쓰레드 downloaded_pages 가 비어있지 않을 때 까지 계속 while 루프 sleep 시켜서 10 밀리초 뒤에 다시 확인 하도록 -> 계속 확인하면 비효율content 를 처리 front 를 통해서 맨 앞의 원소를 얻은 뒤에, pop 을 호출하면 맨 앞의 원소를 큐에서 제거

condition_variable

condition_variable wait 함수에 어떤 조건이 참이 될때 까지 기다릴지 해당 조건을 인자로 전달

-notify_one 모든 쓰레드를 깨워서 조건을 검사

example code

#include               // std::chrono::miliseconds
#include   // std::condition_variable
#include 
#include 
#include 
#include 
#include 
#include 

void producer(std::queue* downloaded_pages, std::mutex* m,
              int index, std::condition_variable* cv) {
  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();

    // consumer 에게 content 가 준비되었음을 알린다.
    cv->notify_one();
  }
}

void consumer(std::queue* downloaded_pages, std::mutex* m,
              int* num_processed, std::condition_variable* cv) {
  while (*num_processed < 25) {
    std::unique_lock lk(*m);

    cv->wait(
        lk, [&] { return !downloaded_pages->empty() || *num_processed == 25; });

    if (*num_processed == 25) {
      lk.unlock();
      return;
    }

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

    (*num_processed)++;
    lk.unlock();

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

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

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

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

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

  // 나머지 자고 있는 쓰레드들을 모두 깨운다.
  cv.notify_all();

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

함수 객체

Fri, 24 Jun 2022 05:16:49 GMT

*씹어먹는 C++ *

15장 함수 객체 705p-718p

Callable

( )를 붙여서 호출(call) 할 수 있는 모든 것 함수, 객체, 람다 함수 etc.

std::function

함수 뿐만이 아니라 모든 Callable 들을 보관할 수 있는 객체 템플릿 인자로 전달 받을 함수의 타입(리턴값과 함수 인자들)을 갖음 std::function<리턴값(함수인자)> [이름] = [받을 callable];

example code

#include 
#include 
#include 

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 f1 = some_func1;
  std::function f2 = S();
  std::function f3 = []() { std::cout << "Func3 호출! " << std::endl; };
  f1("hello");
  f2('c');
  f3();
}

Func1 호출! hello Func2 호출! c Func3 호출!

멤버 함수를 갖는 std::function

멤버 함수

구현 상 자신을 호출한 객체를 인자로 암묵적으로 받음
원래 인자에 추가적으로 객체를 받는 인자를 전달
암시적 변환이 발생하지 않으므로 & 연산자를 통해 명시적으로 주소값을 전달
호출 하려는 객체를 인자로 전달하여 해당 객체의 멤버 함수를 호출한 것 처럼 사용

example code

#include 
#include 
#include 

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);
  std::function f1 = &A::some_func;
  std::function f2 = &A::some_const_function;


  f1(a);
  f2(a);
}

비상수 함수: 6 상수 함수: 6

mem_fn

std::mem_fn

전달된 멤버 함수를 function 객체로 만들어서 리턴 즉 멤버 함수들을 함수 객체로 만들어 전달

반복을 피하기 위해 사용 인자로 전달하는 함수가 멤버 함수일때 정확한 전달을 위해 std::function 으로 변환해서 전달 해야함 해당 일을 반복하지 않기 위해 mem_fn 사용
헤더를 추가
람다 함수로도 동일한 작업을 수행 가능

example code

#include 
#include 
#include 
#include 
using std::vector;

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

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

   vector size_vec(4);
   //mem_fn을 통해 간단히 멤버 함수를 넘김
   transform(container.begin(), container.end(), size_vec.begin(),std::mem_fn(&vector::size));
   /*람다 함수로도 가능
   std::mem_fn(&vector::size)
   = [](const auto&v){ return v.size()}
   */
   for (auto itr = size_vec.begin(); itr != size_vec.end(); ++itr) {
           std::cout << "벡터 크기 :: " << *itr << std::endl;
  }
}

벡터 크기 :: 1 벡터 크기 :: 2 벡터 크기 :: 3 벡터 크기 :: 4

std::bind

원래 함수에 특정 인자를 붙여(bind) 줌 함수 객체 생성 시에 인자를 특정한 것으로 지정

example code

#include 
#include 

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() {
  //add 함수의 첫번째 인자로 2를 bind
  auto add_with_2 = std::bind(add, 2, std::placeholders::_1);
  //두번째 인자로 새롭게 만들어진 함수 객체의 첫번째 인자 전달
  add_with_2(3);

  // 여러 인자 전달시 필요한 인자 이후는 다 무시된다.
  add_with_2(3, 4);

  //placeholders_1, _2 -> 일일히 정의된 객체들
  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 를 계산한다
}

2 + 3 = 5 2 + 3 = 5 3 - 2 = 1 2 - 4 = -2

※ 레퍼런스를 인자로 받는 함수 유의 bind 함수로 인자가 복사 되서 전달 따라서 명시적으로 레퍼런스 전달이 필요

// 명시적 레퍼런스 전달 std::ref() 사용
auto do_something_with_s1 = std::bind(do_something, std::ref(s1), std::placeholders::_1);

ref() 함수 전달 받은 인자를 복사 가능한 레퍼런스로 변환
cref() 함수 ref 함수에서 const 레퍼런스 인자를 위해 사용

스마트 포인터

Fri, 24 Jun 2022 05:15:49 GMT

*씹어먹는 C++ *

14장 스마트 포인터 671p-704p

C++ 자원 관리

자원 해제 프로그래머가 직접 해제 필요

한번 받은 자원은 직접 해제해주지 않는 이상 프로그램이 종료되기 전 까지 영원히 남아있음 종료시에 운영체제가 알아서 해제

제대로 종료하지 않으면 포인터는 존재하지 않는데 heap에는 해당 객체가 남아있는 메모리 누수 발생

** C++ 잘못된 방식 메모리 관리 할시의 문제 **

1) 메모리를 사용한 후에 해제하지 않은 경우

시스템 메모리가 부족해져서 서버가 죽어버리는 상황이 발생
RAII를 통해 사용이 끝난 메모리는 항상 해제시켜 메모리 누수 문제 사전 방지 가능

2) 이미 해제된 메모리를 다시 참조하는 경우

double free 버그 이미 소멸된 객체를 다시 소멸시켜서 발생하는 버그
주로 만들어진 객체의 소유권이 명확하지 않아서 발생

스마트 포인터 (smart pointer)

RAII (Resource Acquisition Is Initialization)패턴

자원 (이 경우 메모리) 관리를 스택의 객체 (포인터 객체) 를 통해 수행

C++에서 두 가지 형태의 새로운 스마트 포인터를 제공

unique_ptr
shared_ptr

unique_ptr

특정 객체에 유일한 소유권을 부여하는 포인터 객체

-> 연산자를 오버로드 포인터를 다루는 것과 같이 사용 가능
unique_ptr 은 어떤 객체의 유일한 소유권을 나타내는 포인터, unique_ptr 가 소멸될 때, 가리키던 객체 역시 소멸
만약 다른 함수에서 unique_ptr 가 소유한 객체에 일시적으로 접근시, get 을 통해 해당 객체의 포인터를 전달.
만약에 소유권을 이동을 원하면, unique_ptr 를 move

example code

#include 
#include 

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;
  }
};

//unique_ptr 사용
void do_something() {
  //A* pa = new A();와 같다
  std::unique_ptr pa(new A());
  pa->some();
}

int main() { do_something(); }

자원을 획득함! 일반 포인터와 동일하게 사용가능! 자원을 해제함!

unique_ptr 복사 불가능

unique_ptr의 복사 생성자는 명시적으로 삭제되어 복사 불가능 어떠한 객체를 유일하게 소유하여야 하기 때문
example code

class A {
  public:
  A(int a){};
  A(const A& a) = delete; 
  /* 명시적으로 삭제하여 
  해당 함수를 사용할 수 없도록 함*/
};
int main() {
  A a(3); // 가능
  A b(a); // 불가능 (복사 생성자는 삭제됨)
}

unique_ptr 소유권 이전

unique_ptr 복사는 불가능하나 소유권 이전은 가능 즉 이동생성자는 가능함 move로 소유권을 이동시키는 것이므로

std::unique_ptr pb = std::move(pa); 새로 생성된 pb이 소유권을 갖음 pa는 nullptr 즉 아무것도 가르키지 않음

댕글링 포인터(dangling pointer) 소유권이 이전된 unique_ptr을 재 참조 할 시 런타임 오류 접근 하진 않도록 주의

unique_ptr 함수 인자로 전달

레퍼런스로 넘기면 소유의 권한에 위배 std::unique_ptr& ptr 형태 < 올바르지 않음 원래의 포인터 주소값으로 넘김 pa.get() 형태로 넘기며(A* ptr)형태로 인자를 받으면 됨

unique_ptr 쉽게 생성

std::make_unique 함수 사용 템플릿 인자로 전달된 클래스의 생성자에 인자들에 직접 완벽한 전달 수행

example code

#include 
#include 

class Foo {
  int a, b;
  public:
  Foo(int a, int b) : a(a), b(b) { std::cout << "생성자 호출!" << std::endl; }
  void print() { std::cout << "a : " << a << ", b : " << b << std::endl; }
  ~Foo() { std::cout << "소멸자 호출!" << std::endl; }
};

int main() {
  auto ptr = std::make_unique(3, 5);
  //std::unique_ptr ptr(new Foo(3, 5)); 불필요
  ptr->print();
}

생성자 호출! a : 3, b : 5 소멸자 호출!

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

복사 생성자가 없는 특성을 지님

vector push_back함수 전달된 인자를 복사하여 집어 넣으므로 사용 불가능 명시적으로 vector안으로 이동 > push_back의 우측값 레퍼런스 오버로딩하여 사용

emplace_back 함수 vector 안에 unique_ptr 을 직접 생성하며 집어넣기 가능 완벽한 전달(perfect forwarding) 을 통해, 직접 unique_ptr 의 생성자에 전달 vector 맨 뒤에 unique_ptr 객체를 생성 즉, 불필요한 이동 과정을 생략 가능
주의 어떤 생성자로 emplace_back하는지 확인 할 것. 요상한게 생성 될 수도 있다. int 1000인 원소를 원했으나 원소 1000개인 벡터를 추가하게 될 수 도...

example code

int main() { std::vector> vec; std::unique_ptrpa(new A(1)); //다음과 동일 //vec.emplace_back(new A(1)); vec.push_back(std::move(pa)); // 잘 실행됨 }

shared_ptr

여러 개의 스마트 포인터가 하나의 객체를 같이 소유 해야 하는 경우

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

example code

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

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

  /* 여러개의 ptr로 하나의 객체를 가르키는 것 가능
  아래 3개는 모두 같은 객체를 가르키는 shared_ptr*/

  vec.push_back(std::shared_ptr(new A()));
  vec.push_back(std::shared_ptr(vec[0]));
  vec.push_back(std::shared_ptr(vec[1]));

  // 벡터의 첫번째 원소를 소멸 시킨다.
  std::cout << "첫 번째 소멸!" << std::endl;
  vec.erase(vec.begin());
  // 그 다음 원소를 소멸 시킨다.
  std::cout << "다음 원소 소멸!" << std::endl;
  vec.erase(vec.begin());
  // 마지막 원소 소멸
  std::cout << "마지막 원소 소멸!" << std::endl;
  vec.erase(vec.begin());
  std::cout << "프로그램 종료!" << std::endl;
}

자원을 획득함! 첫 번째 소멸! 다음 원소 소멸! 마지막 원소 소멸! 소멸자 호출! 프로그램 종료!

A객체의 erase가 ref count가 0이 되어야만 소멸자를 호출 즉 마지막 erase만 소멸자를 호출 가능

참조 개수 (reference count)

여러개의 소유권 가능 > ref count 증가 해당 참조 개수가 0이 되어야 해당 객체 해제 가능 모든 스마트 포인터 들이 소멸되어야만 객체 파괴 가능해짐

use_count 함수 ref count 개수 확인 p1.use_count();
제어 블록 사용 하여 공유 실제 객체를 가리키는 shared_ptr 가 제어 블록(control block) 을 동적으로 할당 이후 shared_ptr 들이 이 제어 블록에 필요한 정보 공유하도록 구현 복사 생성할 때 마다 해당 제어 블록의 위치만 공유
shared_ptr에서 생성 시 제어 블록의 참조 개수 ++ 소멸 시 제어 블록의 참조 개수 --하도록 작동

make_shared 로 생성

std::shared_ptr p1(new A());> 바람직 하지 않음 해당 방법은 동적 할당을 2번 해야함

make_shared 함수 아예 두 개 합친 크기로 한 번 할당 하는 것이 훨씬 빠름 생성자의 인자들을 받아 객체 A 와 shared_ptr 의 제어블록 까지 한 번에 동적 할당 후 생성한 shared_ptr 을 리턴 std::shared_ptr p1 = std::make_shared();

shared_ptr 생성 시 주의

shared_ptr 은 인자로 주소값이 전달이 되면 해당 ptr이 첫번째가 되어버림 즉 주소값을 인자로 넘기면 각 ptr 제어블록 각각 생성

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

p1이 ref count 0으로 해당 A 객체를 삭제 하면 p2는 이미 해제된 객체를 가키며, 소멸 시키려 하여 오류가 발생

enable_shared_from_this

this 를 사용해서 shared_ptr 생성을 원하는 클래스가 있다면, 즉 객체 내부에서 자기 자신을 가리키는 shared_ptr 원하면

enable_shared_from_this 를 상속 받아 사용

enable_shared_from_this 클래스
- shared_from_this는 제어 블록 확인만 함 생성은 안함 즉, 해당 객체의 shared_ptr가 반드시 먼저 정의 되어야 함
```
//불가능
A* a = new A();
std::shared_ptr pa1 = a->get_shared_ptr();
```

example code

#include 
#include 

class A : public std::enable_shared_from_this {
  int *data;
  public:
    A() {
      data = new int[100];
      std::cout << "자원을 획득함!" << std::endl;
    }
    ~A() {
      std::cout << "소멸자 호출!" << std::endl;
      delete[] data;
      }
    std::shared_ptr get_shared_ptr() { return shared_from_this(); }
};
int main() {
  std::shared_ptr pa1 = std::make_shared();
  std::shared_ptr pa2 = pa1->get_shared_ptr();

  std::cout << pa1.use_count() << std::endl;
  std::cout << pa2.use_count() << std::endl;
}

자원을 획득함! 2 2 소멸자 호출!

서로 참조하는 shared_ptr

순환 참조 객체들을 더이상 사용하지 않아도 참조 개수가 절대로 0 이 될 수 없는 상황 shared_ptr 자체에 내재되어 있는 문제 > weak_ptr로 해결

weak_ptr

일반 포인터와 shared_ptr 사이에 위치한 스마트 포인터

스마트 포인터 처럼 객체를 안전하게 참조 shared_ptr 와는 다르게 참조 개수 늘리지 않음.

어떤 객체를 weak_ptr가 가리키더라도, 다른 shared_ptr를 사용하지 않으면 이미 메모리에서 소멸

weak_ptr 자체로는 원래 객체를 참조 불가능 반드시 shared_ptr 로 변환해서 사용 참조 하려는 객체가 이미 소멸되었다면 빈 shared_ptr 로 변환 아닐경우 해당 객체를 가리키는 shared_ptr 로 변환 -> lock 함수를 통해 수행

제어 블록을 메모리에서 해제 가리키는 weak_ptr 또한 0 개여야 가능 따라서 제어 블록에는 참조 개수와 더불어 약한 참조 개수 (weak count) 기록

example code

#include 
#include 
#include 
#include 

class A {
  std::string s;
  std::weak_ptr other;

  public:
    A(const std::string& s) : s(s) { std::cout << "자원을 획득함!" << std::endl; }
    ~A() { std::cout << "소멸자 호출!" << std::endl; }
    //weak_ptr 사용
    void set_other(std::weak_ptr o) { other = o; }
    void access_other() {
      std::shared_ptr o = other.lock();
      if (o) {
          std::cout << "접근 : " << o->name() << std::endl;
      } else {
          std::cout << "이미 소멸됨 ㅠ" << std::endl;
      }
    }
    std::string name() { return s; }
};
int main() {
  std::vector> vec;
  vec.push_back(std::make_shared("자원 1"));
  vec.push_back(std::make_shared("자원 2"));

  vec[0]->set_other(vec[1]);
  vec[1]->set_other(vec[0]);

  // pa 와 pb 의 ref count 는 그대로다.
  std::cout << "vec[0] ref count : " << vec[0].use_count() << std::endl;
  std::cout << "vec[1] ref count : " << vec[1].use_count() << std::endl;

  // weak_ptr 로 해당 객체 접근하기
  vec[0]->access_other();

  // 벡터 마지막 원소 제거 (vec[1] 소멸)
  vec.pop_back();
  vec[0]->access_other(); // 접근 실패!
}

자원을 획득함! 자원을 획득함! vec[0] ref count : 1 vec[1] ref count : 1 접근 : 자원 2 소멸자 호출! 이미 소멸됨 ㅠ 소멸자 호출!

이동 연산

Fri, 24 Jun 2022 05:13:47 GMT

*씹어먹는 C++ *

13장 우측값과 이동 연산 649p-670p

if lvalue를 이동 시키고 싶다면?

template 
void my_swap(T &a, T &b) {
T tmp(a);
a = b;
b = tmp;
}

swap 함수를 이용하여 임시 객처 생성 후 복사 복사

즉, 불필요한 복사를 3번 진행 굳이 복사할 필요 없이 각 MyString 객체의 string_content 주소값만 서로 바꿔주면 해결 가능
하지만* a 가 좌측값이라 이상태에서는 이동 생성자 오버로딩 불가능
move 함수 사용하여 해결

Move 함수 (Move semantics)

좌측값을 우측값으로 바꾸어주는 함수 인자로 받은 객체를 우측값으로 타입 변환만 수행하여 리턴

library 사용

example code


#include 
#include 

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));
}

일반 생성자 호출! --------- 복사 생성자 호출! --------- 이동 생성자 호출!

이동 연산자(operater =)을 사용한 swap 이동 생성이므로 복사 생성 보다 훨씬 빠르게 수행

template 
void my_swap(T &a, T &b) {
T tmp(std::move(a));
a = std::move(b);
b = std::move(tmp);
}

이동 자체는 move를 통해서가 아니라 우측값을 받는 함수들이 오버로딩 되면서 수행되는 것

완벽한 전달 (perfect forwarding)

문맥에 따라 & L-value Reference, && R-value Reference 을 구분하지 못하는 경우 std::forward를 통해 타입을 분명하게 해줌 우측값 레퍼런스 일 때 에만 마치 move 를 적용한 것 처럼 작동 std::forward(u)

주의 좌측값 레퍼런스일 때 move 를 해버린다면 좌측값에 오버로딩 되는 g 가 아닌 우측값에 오버로딩 되는 g 가 호출 -> 이경우 forward 사용 g(std::forward(u));

구분을 못하는 경우

C++ 컴파일러가 템플릿 타입을 추론할 때, 템플릿 인자 T 가 레퍼런스가 아닌 일반적인 타입이라면 const 를 무시 즉, wrapper에서 T가 전부 class A 로 추론함 -> 세 경우 전부 다 좌측값 레퍼런스를 호출

example code

#include 
#include 
template 
  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 ----- 좌측값 레퍼런스 호출 좌측값 레퍼런스 호출 좌측값 레퍼런스 호출

보편적 레퍼런스(Universal reference)

T&& 템플릿 인자 T에 대해서, 우측값 레퍼런스로 받는 형태 또한 다른 타입의 레퍼런스와 다르게 우측값 뿐만 아니라 좌측값도 받는 것도 가능

-> 레퍼런스 겹침 규칙 (reference collapsing rule) 에 따라 T 의 타입을 추론함

example code

#include 
#include 

/* T&& 보편적 레퍼런스 
    forward 함수 사용 */
template 
void wrapper(T&& u) {
    g(std::forward(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 ----- 좌측값 레퍼런스 호출 좌측값 상수 레퍼런스 호출 우측값 레퍼런스 호출

참고 https://ansohxxn.github.io/cpp/chapter19-7/ https://lakanto.tistory.com/46

Rvalue & Lvalue

Wed, 15 Jun 2022 07:32:59 GMT

*씹어먹는 C++ *

13장 우측값과 이동 연산 630p-648p

복사 생략(Copy Elision)

컴파일러 자체에서 복사를 생략해 버리는 작업 필요에 따라 굳이 임시 객체를 한 번 만들고, 이를 복사 생성할 필요 없음 (함수의 인자가 아닌) 함수 내부에서 생성된 객체를 그대로 리턴할 때, 복사 생략 수행

nullptr 기존의 NULL 대체 포인터 주소값 0 정확히 명시 string_content = nullptr;

만약 복사 생략 수행하지 않을시 쓸데 없는 복사를 두 번 하는데 상당한 자원이 소모 어차피 똑같이 복사해서 생성할 것이면, 이미 생성된 (str1 + str2) 가 리턴한 객체를 str3으로 사용가능 해당 문제를 해결하려면 str3 생성 시에 임시로 생성된 객체의 string_content 가리키는 문자열의 주소값을 str3 의 string_content 문자열 사라짐 방지를 위해 nullptr로 사용

좌측값 (lvalue) 와 우측값 (rvalue)

좌측값 (lvalue) 좌측값은 어떠한 표현식의 왼쪽 오른쪽 모두 가능 메모리 상에서 존재하는 변수
우측값(rvalue) 표현식을 연산 시에만 잠깐 존재할 뿐 연산 후 사라지는 값
```
 실체가 없는 값
```
우측값은 항상 오른쪽

example code

int a; // a 는 좌측값
int& l_a = a; // l_a 는 좌측값 레퍼런스
int& r_b = 3; // 3 은 우측값. 따라서 오류

좌측값 레퍼런스 (lvalue 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; // 오류 
}

위 예시 처럼 래퍼런스 리턴시 리턴값의 주소값을 가져오는 것 가능 lvalue로 사용 가능 하지만 일반 int값 리턴시 리턴 값은 실체가 없음

const 레퍼런스 예외적 타입에 한해서 우측값도 래퍼런스로 받기 가능 임시로 존재하는 객체의 값을 참조만 가능 변경 불가능 하기 때문

우측값 레퍼런스

& 를 두 개 사용해서 정의 우측값만 특이적으로 받기 위해 사용 레퍼런스를 갖는 해당 임시 객체가 소멸되지 안도록 한다.

example code

int a;
int& l_a = a;
int& ll_a = 3; // 불가능
int&& r_b = 3;
int&& rr_b = 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;
}

위 생성자는 Mystring타입의 우측값 인자 받음. 기존의 복사 생성자의 경우 문자열 전체를 새로 복사, 이동 생성자의 경우 단순히 주소값 하나만 복사.

주소값을 복사하므로 임시 객체가 소멸 시 delete 안 되도록 해야함 즉, 소멸자 또한 nullptr이 아닐 때만 delete

vector 복사 생성자 이용시 복사 생성 과정에서 예외 발생시 새로 할당한 메모리 소멸 후 예외처리
하지만 vector 이동 생성자 이용시 이동 생성의 경우 기존 메모리를 원소에 이동시켰으므로 기존에 메모리에 남은 원소들이 없음 즉, 섯불리 해제 불가능 vector는 noexcept이 아닌 이상 이동 생성자를 사용하지 않음

C++ 예외 처리

Wed, 15 Jun 2022 07:31:42 GMT

*씹어먹는 C++ *

12장 c++에서의 예외 처리 613p-629p

예외(exception)

정상적인 상황에서 벗어난 모든 예외적인 상황

문법 상 틀린 것이 없는 코드라도 실제로 실행 시 오류발생 가능성 있음

예외를 계속 체크하는 데 있어서 시스템 로드가 생김 성능이 떨어지면 잘 안씀...

throw

예외가 발생 사실을 명시적으로 나타냄

예외로 전달하고 싶은 객체 throw 여러 종류 예외 라이브러리 사용
throw 한 위치에서 즉시 함수가 종료 후 예외 처리 부분까지 점프 점프하며서 stack 에 생성되었던 객체들을 빠짐없이 소멸

example code

const T& at(size_t index) const {
  if (index >= size) {
    // 예외를 발생시킨다!
    throw std::out_of_range("vector 의 index 가 범위를 초과하였습니다.");
  }
  return data[index];
}

try 와 catch

try 무언가 예외가 발생할만한 코드가 실행

예외가 없다면 catch 문은 무시
예외가 있다면 stack 에 생성된 모든 객체들의 소멸자들이 호출되고, 가장 가까운 catch 문으로 점프

catch throw 된 예외를 받는 부분 정의된 예외의 꼴에 맞는 객체로 받음

template 
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 std::out_of_range("vector 의 index 가 범위를 초과하였습니다.");
    }
    return data_[index];
  }~
  Vector() { delete[] data_; }
private:
  T* data_;
  size_t size_;
}; 

int main() {
  Vector 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;
}

스택 풀기 (stack unwinding)

catch 로 점프 하면서 스택 상에서 정의된 객체들을 소멸 각 객체의 소멸자 호출하여 소멸

여러 종류의 예외 받기

catch문 여러 종류의 예외들을 받기 가능 각기 다른 타입으로 throw 하면 작동하는 catch가 달라짐

기반 파생 클래스의 catch 주의 Parent catch 를 Child catch 보다 뒤에 쓰자
> 기반 클래스 레퍼런스나 포인터에 파생 클래스 객체를 정의시 catch에서 기반 클래스를 catch를 타게됨

example code

int func(int c) {
  if (c == 1) {
      throw 10;
  } else if (c == 2) {
      throw std::string("hi!");
  } else if (c == 3) {
      throw 'a';
  } else if (c == 4) {
      throw "hello!";
  }
  return 0;
}

int main() {
  int c;
  std::cin >> c;

  try {
      func(c);
  } 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;
  }
}

모든 예외 받기

어떤 예외를 throw but, 받는 catch 가 없을 수 있음

catch(...) try 안에서 발생한 모든 예외들을 받음

example code


int func(int c) {
  if (c == 1) {
      throw 1;
  } else if (c == 2) {
      throw "hi";
  } else if (c == 3) {
      throw std::runtime_error("error");
  }
  return 0;
}

int main() {
  int c;
  std::cin >> c;

  try {
      func(c);
  } catch (int e) {
      std::cout << "Catch int : " << e << std::endl;
  } catch (...) {
      std::cout << "Default Catch!" << std::endl;
  }
}

noexcept

명시적으로 함수가 예외 발생 시키지 않음을 표현

int foo() noexcept {}

물론 키워드가 있다 해서 반드시 예외를 던지지 않지는 않음 만약 예외를 던지게 예외가 처리되지 않고 비정상 종료됨

C++ 11 에서 부터 소멸자들은 기본적으로 noexcept 절대로 소멸자에서 예외를 던질 수 없음

c++ 표준 라이브러리(stl)

Fri, 10 Jun 2022 01:47:59 GMT

*씹어먹는 C++ *

11장 c++ 표준 라이브러리(stl) 494p-555p 11장-3, 11장-4 556p - 612p

대표적 C++ STL

컨테이너 임의 타입의 객체를 보관
반복자 컨테이너에 보관된 원소에 접근
알고리즘 반복자들을 가지고 일련의 작업을 수행

컨테이너

시퀀스 컨테이너 (sequence container)

배열 처럼 객체들을 순차적으로 보관 vector, list, deque

vector 일반적인 상황에서는 그냥 벡터를 사용. 거의 만능
list 맨 끝이 아닌 중간에 원소들을 추가하거나 제거 많고 원소들을 순차적으로만 접근시 사용
deque 맨 처음과 끝 모두에 원소들을 추가 많으면 사용

Vector

원소들이 메모리 상에서 실제로 순차적으로 저장 임의의 위치의 원소를 접근 매우 빠르게 수행

복잡도(complexity) O(1) 임의의 위치의 원소를 접근 맨 뒤에 새로운 원소를 추가하거나 제거

amortized O(1)
```
 미리 더 많은 공간 할당 > 다쓰면 O(n)
```
접근 [ ] , at()
위치 begin() 첫번째 원소 end() 마지막 원소 +1칸 빈 벡터를 표현 가능 begin() == end()
추가 및 제거 맨 뒤에 원소를 추가하거나 제거 push_back()/ pop_back()
size() 벡터의 크기를 리턴하는 함수 값의 타입은 size_type 멤버 타입

example code


int main() {
  std::vector vec;
  vec.push_back(10); // 맨 뒤에 10 추가
  vec.push_back(20); // 맨 뒤에 20 추가
  vec.push_back(30); // 맨 뒤에 30 추가
  vec.push_back(40); // 맨 뒤에 40 추가

  for (std::vector::size_type i = 0; i < vec.size(); i++) {
  std::cout << "vec 의 " << i + 1 << " 번째 원소 :: " << vec[i] << std::endl;
  }
}

vec 의 1 번째 원소 :: 10 vec 의 2 번째 원소 :: 20 vec 의 3 번째 원소 :: 30 vec 의 4 번째 원소 :: 40

반복자

RandomAccessIterator 반복자

컨테이너에 iterator 멤버 타입

vetcor begin() end() std::vector<>::iterator 멤버 타입으로 정의

* 연산자 오버로딩 itr이 가르키는 원소 확인
+ 연산자 오버로딩 itr에서 해당 크기만큼 덜어진 원소 가르킴
insert erase 사용 가능 ※ 오류 주의 erase로 itr를 지우면 해당 값은 유효한 값이 아님 반드시 새로운 값을 넣어줘야 itr을 다시 사용 가능 디버깅시 주의
const_iterator const 포인터처럼 가리키고 있는 원소의 값을 바꿀 수 없음
역반복자 (reverse iterator) 벡터 뒤에서 부터 앞으로 거꾸로 간다는 특징 (const_reverse_iterator 타입도 있음) rbegin() / rend() std::vector::reverse_iterator r_iter = vec.rbegin();

example code

#include 
#include 

template 
void print_vector(std::vector& vec) {
  // 전체 벡터를 출력하기
  // typename 필요 > iterator 가 std::vector
의 의존 타입
  for (typename std::vector::iterator itr = vec.begin(); itr != vec.end();
  ++itr) {
      std::cout << *itr << std::endl;
  }
}

int main() {
  std::vector vec;
  vec.push_back(10);
  vec.push_back(20);
  vec.push_back(30);
  vec.push_back(40);

  std::cout << "처음 벡터 상태" << std::endl;
  print_vector(vec);
  std::cout << "----------------------------" << std::endl;

  // vec[2] 앞에 15 추가
  vec.insert(vec.begin() + 2, 15);
  print_vector(vec);
  std::cout << "----------------------------" << std::endl;

  // vec[3] 제거
  vec.erase(vec.begin() + 3);
  print_vector(vec);
}

처음 벡터 상태 10 20 30 40 ---------------------------- 10 20 15 30 40 ---------------------------- 10 20 15 40

범위 기반 for 문 (range based for loop)

for문 패턴을 매우 간단하게 나타낼 수 있는 방식을 제공

for (/* 원소를 받는 변수 정의 */ : /* 컨테이너 */) { }

example code

template 
void print_vector(std::vector& vec) {
  // 전체 벡터를 출력하기
  for (typename std::vector::iterator itr = vec.begin(); itr != vec.end();
  ++itr) {
      std::cout << *itr << std::endl;
  }
}
template 
void print_vector_range_based(std::vector& vec) {
  // 전체 벡터를 출력하기
  // 범위 기반 for 문 레퍼런스 사용
  for (const auto& elem : vec) {
      std::cout << elem << std::endl;
  }
}
int main() {
  std::vector vec;
  vec.push_back(1);
  vec.push_back(2);
  vec.push_back(3);
  vec.push_back(4);
  std::cout << "print_vector" << std::endl;
  print_vector(vec);
  std::cout << "print_vector_range_based" << std::endl;
  print_vector_range_based(vec);
  return 0;
}

print_vector 1 2 3 4 print_vector_range_based 1 2 3 4

List

양방향 연결 구조를 가진 자료형

example code

#include 
#include 

int main() {
  std::list lst;
  lst.push_back(10);
  lst.push_back(20);
  lst.push_back(30);
  lst.push_back(40);

  for (std::list::iterator itr = lst.begin(); itr != lst.end(); ++itr) {
      std::cout << *itr << std::endl;
  }
}

10 20 30 40

접근 임의의 위치의 원소에 바로 접근 불가능 임의의 위치의 원소 접근을 위해 하나씩 링크를 따라가야함
반복자 (BidirectionalIterator)
+, -- 연산자는 가능 < 한칸씩 움직인 위치 접근 가능 + 3, - 5 연산자 불가능 < 임의의 위치 원소 접근 못함
앞뒤의 insert erase 사용 원소를 추가하거나 제거하는 작업이 O(1) 으로 매우 빠르게 수행됨 원하는 위치 앞과 뒤에 있는 링크 값만 바꿈
원소를 지워도 반복자가 무효화 안음 itr를 계속 사용가능

deque - double ended queue

덱

실행 속도를 위해 메모리를 (많이) 희생하는 컨테이너

O(1)으로 수행 임의의 위치의 원소에 접근 맨 앞 및 맨 뒤에 원소를 추가/제거 하는 작업
원소들이 실제로 메모리 상에서 연속적으로 존재 않음 추가적 메모리 필요 < 원소들의 저장 위치 정보 보관 필요
메모리
일정 크기로 잘려서 각각의 블록 속에 존재 블록의 메모리 위치 주소 정보 저장을 위해 벡터 사용 새로 할당 시에 앞쪽 및 뒤쪽 모두에 공간 남겨 사용

#include 
#include 

template 
void print_deque(std::deque& dq) {
  // 전체 덱을 출력하기
  std::cout << "[ ";
  for (const auto& elem : dq) {
      std::cout << elem << " ";
  }
  std::cout << " ] " << std::endl;
}

int main() {
  std::deque dq;
  dq.push_back(10);
  dq.push_back(20);
  dq.push_front(30);
  dq.push_front(40);

  std::cout << "초기 dq 상태" << std::endl;
  print_deque(dq);
  std::cout << "맨 앞의 원소 제거" << std::endl;
  dq.pop_front();
  print_deque(dq);
}

초기 dq 상태 [ 40 30 10 20 ] 맨 앞의 원소 제거 [ 30 10 20 ]

연관 컨테이너(associative container)

키(key) - 값(value) 구조 특정한 키를 넣으면 이에 대응되는 값 리턴 키와 값 모두 임의의 타입의 객체 가능

키의 존재 유무 / 대응 되는 값 질의 두가지 타입으로 나뉨 set, mulitset / map, multimap

set 데이터의 존재 유무 만 궁금할 경우
multiset 중복 데이터를 허락할 경우 insert, erase, find 모두 O(log N). 최악도 O(log N))
map 데이터에 대응되는 데이터를 저장하고 싶은 경우
multimap 중복 키를 허락할 경우 insert, erase, find 모두 O(log N). 최악도 O(log N))
- unordered_set, unordered_map 속도가 매우매우 중요해서 최적화를 해야하는 경우 insert, erase, find 모두 O(1) 최악은 O(N) 그러므로 해시함수와 상자 개수 설정 유의

셋(set)

트리 구조로 되어 있음 find 최적화

추가 insert() 위치정보 없이 추가 추가 시 정렬된 상태를 유지 O(logN)
원소 위치 정보가 아닌 유무가 중요한 정보
반복자 BidirectionalIterator 순차적 접근만 가능
find 원소의 존재 유무 확인 정렬된 상태 유지하므로 O(logN) 존재 시 반복자 리턴 존재 하지 않을시 s.end() 리턴- 중복 중복된 원소 추가 불가능 있는데 추가시 무시함

-원하는 타입 셋 사용 크기 비교가 있어야 사용가능 < 정렬을 사용하기 때문 즉 operater <에 대한 정의로 오버로딩 필요 operator< 조건이 모두 만족해야 접근 가능 또는 함수 객체 사용 const 사용 하여 전달 : 셋 내부적으로 정렬 시에 상수 반복자를 사용

example code

 #include 
#include 
template 
void print_set(std::set& s) {
  // 셋의 모든 원소들을 출력하기
  std::cout << "[ ";
  for (typename std::set::iterator itr = s.begin(); itr != s.end(); ++itr) {
      std::cout << *itr << " ";
  }
  std::cout << " ] " << std::endl;
}

int main() {
  std::set s;
  s.insert(10);
  s.insert(50);
  s.insert(20);
  s.insert(40);
  s.insert(30);

  std::cout << "순서대로 정렬되서 나온다" << std::endl;
  print_set(s);

  std::cout << "20 이 s 의 원소인가요? :: ";
  auto itr = s.find(20);
  if (itr != s.end()) {
      std::cout << "Yes" << std::endl;
  } else {
      std::cout << "No" << std::endl;
  }

  std::cout << "25 가 s 의 원소인가요? :: ";
  itr = s.find(25);
  if (itr != s.end()) {
      std::cout << "Yes" << std::endl;
  } else {
    std::cout << "No" << std::endl;
  }
}

순서대로 정렬되서 나온다 [ 10 20 30 40 50 ] 20 이 s 의 원소인가요? :: Yes 25 가 s 의 원소인가요? :: No

맵 (map)

키에 대응되는 값(value) 까지도 같이 보관

키와 값 템플릿 인자 2 개 첫번째는 키의 타입, 두 번째는 값의 타입
맵에 원소를 넣기 위해서는 반드시 std::pair 객체를 전달 make_pair() 사용 < pair 역시 stl (utility 헤더 사용) operator[]도 사용가능
반복자 맵 반복자가 std::pair 객체 tr->first 키, itr->second 원소
탐색 키를 통해 원소 확인 find함수 사용 itr = m.find(key) itr->second find 없는키 참조시 end()리턴 또는 []로 맵에 없는 키를 참조 자동으로 값의 디폴트 생성자를 호출해서 원소를 추가
중복된 원소 추가 불가능 있는데 추가시 무시함

example code

#include 
#include 
#include 
template 
void print_map(std::map& m) {
  // 맵의 모든 원소들을 출력하기
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
      std::cout << itr->first << " " << itr->second << std::endl;
  }
}

int main() {
  std::map pitcher_list;

  // 맵의 insert 함수는 pair 객체를 인자로 받습니다.
  pitcher_list.insert(std::pair("박세웅", 2.23));
  pitcher_list.insert(std::pair("해커 ", 2.93));
  pitcher_list.insert(std::pair("피어밴드 ", 2.95));

  // 타입을 지정하지 않아도 간단히 std::make_pair 함수로
  // std::pair 객체를 만들 수 도 있습니다.
  pitcher_list.insert(std::make_pair("차우찬", 3.04));
  pitcher_list.insert(std::make_pair("장원준 ", 3.05));
  pitcher_list.insert(std::make_pair("헥터 ", 3.09));

  // 혹은 insert 를 안쓰더라도 [] 로 바로
  // 원소를 추가할 수 있습니다.
  pitcher_list["니퍼트"] = 3.56;
  pitcher_list["박종훈"] = 3.76;
  pitcher_list["켈리"] = 3.90;

  print_map(pitcher_list);
  std::cout << "박세웅 방어율은? :: " << pitcher_list["박세웅"] << std::endl;
}

니퍼트 3.56 박세웅 2.23 박종훈 3.76 장원준 3.05 차우찬 3.04 켈리 3.9 피어밴드 2.95 해커 2.93 헥터 3.09 박세웅 방어율은? :: 2.23

멀티셋(multiset)과 멀티맵(multimap)

셋과 맵과는 다르게 중복된 원소를 허락

키와 값 한 개의 키에 여러개의 값이 대응 따라서 operator[] 사용 불가능
여러 키 equal_range 함수 사용 키에 대응되는 원소들의 반복자들중에서 시작과 끝 바로 다음을 가리키는 반복자를 std::pair 객체로 리턴

#include 
#include 
#include 

template 
void print_map(const std::multimap& m) {
  // 맵의 모든 원소들을 출력하기
  for (const auto& kv : m) {
      std::cout << kv.first << " " << kv.second << std::endl;
  }
}

int main() {
  std::multimap m;
  m.insert(std::make_pair(1, "hello"));
  m.insert(std::make_pair(1, "hi"));
  m.insert(std::make_pair(1, "ahihi"));
  m.insert(std::make_pair(2, "bye"));
  m.insert(std::make_pair(2, "baba"));

  print_map(m);
  std::cout << "--------------------" << std::endl;
  // 1 을 키로 가지는 반복자들의 시작과 끝을
  // std::pair 로 만들어서 리턴한다.
  auto range = m.equal_range(1);
  for (auto itr = range.first; itr != range.second; ++itr) {
      std::cout << itr->first << " : " << itr->second << " " << std::endl;
  }
}

1 hello 1 hi 1 ahihi 2 bye 2 baba -------------------- 1 : hello 1 : hi 1 : ahihi

정렬되지 않은 셋과 맵(unordered_set, unordered_-map)

원소가 정렬되어 있지 않음 (셋이나 맵의 경우 원소들이 순서대로 정렬되어서 내부에 저장) 반복자로 원소 출력시 랜덤한 순서로 출력

O(1) insert, erase, find 모두 해시 함수로 구현 즉 최악은 O(n) 최적화가 매우 필요한 작업일 경우에만 해시 함수를 잘 설계해서 사용해야함
원하는 타입 원하는 타입으로 사용하고자 하면 직접 해시 함수 구현

해시 함수(Hash function)

임의의 크기의 데이터를 고정된 크기의 데이터로 대응시켜주는 함수 1 부터 D (= 상자의 수)까지의 값을반환하고 그 해시값 (해시 함수로 계산한 값)을 원소를 저장 같은 원소를 해시 함수에 전달한다면 같은 해시값을 리턴

해시 충돌(hash collision) 다른 원소임에도 불구하고 같은 해시값을 갖는 경우

example code

#include 
#include 
#include 

template 
void print_unordered_set(const std::unordered_set& m) {
  // 셋의 모든 원소들을 출력하기
  for (const auto& elem : m) {
      std::cout << elem << std::endl;
  }
}

template 
void is_exist(std::unordered_set& s, K key) {
  auto itr = s.find(key);
  if (itr != s.end()) {
      std::cout << key << " 가 존재!" << std::endl;
  } else {
      std::cout << key << " 가 없다" << std::endl;
  }
} 

int main() {
  std::unordered_set s;
  s.insert("hi");
  s.insert("my");
  s.insert("name");
  s.insert("is");
  s.insert("psi");
  s.insert("welcome");
  s.insert("to");
  s.insert("c++");

  print_unordered_set(s);
  std::cout << "----------------" << std::endl;
  is_exist(s, std::string("c++"));
  is_exist(s, std::string("c"));
  std::cout << "----------------" << std::endl;
  std::cout << "'hi' 를 삭제" << std::endl;
  s.erase(s.find("hi"));
  is_exist(s, std::string("hi"));
  }

c++ to my name hi is psi welcome --------------- c++ 가 존재! c 가 없다 --------------- 'hi' 를 삭제 hi 가 없다

C++ 표준 알고리즘 라이브러리

여러 함수로 작업

두종류

알고리즘을 수행할 반복자의 시작점과 끝점 바로 뒤를 인자로 받음 template void do_something(Iter begin, Iter end);

반복자는 동일하나 ’특정한 조건’ 을 추가 인자를 받음 template void do_something(Iter begin, Iter end, Pred pred);

’특정한 조건’ - 서술자(Predicate) Pred 에는 보통 bool 을 리턴하는 함수객체(Functor)

정렬 (sort, stable_sort, partial_sort)

sort 일반적인 정렬 함수라 생각하시면 됩니다.
stable_sort 정렬을 하되 원소들 간의 순서를 보존
partial_sort 배열의 일부분만 정렬합니다

sort

오름차순으로 정렬 sort(vec.begin(), vec.end());

임의접근 반복자(RandomAccessIterator) 타입만 가능 즉 벡터와 데크만 가능

내림 차순으로 정렬을 원하면 compare함수 생성하여 사용 greater 사용도 가능 std::sort(vec.begin(), vec.end(), greater());

example code

#include 
#include 
#include 

template 
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 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());
}

정렬 전 ---- 5 3 1 6 4 7 2 정렬 후 ---- 7 6 5 4 3 2 1

partial_sort

정렬을 [stard, end) 전체 원소들 중에서 [start, middle) 까지 원소들이 전체 원소들 중에서 제일 작은애들 순으로 정렬 std::partial_sort(vec.begin(), vec.begin() + 3, vec.end());

stable_sort

원소가 삽입되어 있는 순서를 보존하는 정렬 std::stable_sort(vec2.begin(), vec2.end());

원소 제거 (remove, remove_if)

컨테이너의 원소를 제거하는 함수

erase

vector의 erase pos 가 가리키는 원소를 벡터에서 지움 Iterator erase(Iterator pos); first 부터 last 사이에 있는 모든 원소들을 지움 Iterator erase(Iterator first, Iterator last);

remove

원하는 값을 가진 원소들을 컨테이너 뒤로 보내 지움 즉 지우지 말아야할 원소를 하나씩 앞으로 이동시키는 방식 크기가 지우는게 아니라 땡기는 거다. < 크기가 그대로임 대신 한번에 원하는 값을 갖는 원소 여러개 지우기 가능 보통 erase와 조합하여 사용 시작부터 끝전까지 값 찾아 제거 remove(vec.begin(), vec.end(), 3) vec.erase(remove(vec.begin(), vec.end(), 3), vec.end());

remove_if

시작부터 끝전까지 조건 충족하면 제거 vec.erase(remove_if(vec.begin(), vec.end(), is_odd()), vec.end());

조건을 위한 함수 객체 사용시 유의 ※함수 객체 사용시 주의 객체 내부 변수를 통해절대로 특정 상태를 저장해서 이에 따라 결과가 달라지는 루틴을 짜면 안됨 -> 단순 전달이 아닌 복사나 소멸로 값이 다르게 파악됨

example code

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

struct is_odd {
  bool operator()(const int& i) { return i % 2 == 1; }
};

int main() {
  std::vector 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(), is_odd()), vec.end());
  print(vec.begin(), vec.end());
}

처음 vec 상태 ------ [5] [3] [1] [2] [3] [4] 벡터에서 홀수 인 원소 제거 --- [2] [4]

람다 함수(lambda function)

임시적으로 함수 객체 생성

람다 함수도 함수이므로 자기 자신만의 스코프를 갖음
캡쳐 목록(capture list) 외부 변수를 캡쳐 리스트로 접근 가능 만약 객체 멤버변수를 원하면 해당 객체를 캡쳐(this처럼) [] 아무것도 캡쳐 안함 [&a, b] a 는 레퍼런스로 캡쳐하고 b 는 (변경 불가능한) 복사본으로 캡쳐 [&] 외부의 모든 변수들을 레퍼런스로 캡쳐 [=] 외부의 모든 변수들을 복사본으로 캡쳐

일반적인 꼴 [capture list] (받는 인자) -> 리턴 타입 { 함수 본체 } 리턴 타입 생략 [capture list] ( 받는 인자) {함수 본체}

example code

//함수 객체
struct is_odd {
  bool operator()(const int& i) { return i % 2 == 1; }
};

//람다 함수
[](int i) -> bool { return i % 2 == 1; }

// 바로 호출
[](int i) { return i % 2 == 1; }(3);// true

//함수객체 성성 후 호출
auto func = [](int i) { return i % 2 == 1; };
func(4); // false;

//캡쳐 리스트 사용
[&num_erased](int i) {
  if (num_erased >= 2)
    return false;
  else if (i % 2 == 1) {
    num_erased++;
    return true;
  }
  return false;
}

// 객체를 캡쳐 리스트로 사용
vec.erase(std::remove_if(vec.begin(), vec.end(),
  [this](int i) {
    if (this->num_erased >= 2)
        return false;
    else if (i % 2 == 1) {
      this->num_erased++;
      return true;
    }
    return false;
    }),
  vec.end());

원소 수정하기 (transform)

transform 원소들을 수정하는 함수 컨테이너 전체 혹은 일부를 순회하면서 값들을 수정 transform (시작 반복자, 끝 반복자, 결과를 저장할 컨테이너의 시작 반복자, Pred)

저장하는 컨테이너의 크기가 원래의 컨테이너보다 최소한 같거나 커야함

example code

std::transform(vec.begin(), vec.end(), vec.begin(),[](int i) { return i + 1; });

원소를 탐색하는 함수(find, find_if, any_of, all_of...)

원소들을 탐색하는 계열의 함수

find

first 부터 last 까지 순회하며 value와 같은 값 파악 있다면 이를 가리키는 반복자를 리턴 template InputIt find(InputIt first, InputIt last, const T& value)

중복되는 값이 있더라도 가장 먼저 찾은 것을 리턴
중복 되는 값 찾기 마지막으로 찾은 위치 바로 다음 부터 계속 순차적으로 탐색
current = find(current, vec.end(), 3);
만약 해당 컨테이너에 find가 있다면 해당 컨테이너 find 사용

find_if

함수 객체를 인자로 받아서 그 결과가 참인 원소들을 탐색 current = std::find_if(current, vec.end(), [](int i) { return i % 3 == 2; });

any_of

인자로 받은 범위안의 모든 원소들 중에서 조건을 하나라도 충족하는 것이 있다면 true 리턴 OR 연산과 비슷 std::any_of(users.begin(), users.end(), [](User& user) { return user.level >= 19; });

all_of

모든 원소들이 전부 조건을 충족해야 true 리턴 AND 연산과 비슷 std::all_of(users.begin(), users.end(), [](User& user) { return user.level >= 15; });

C++ 문자열(string 과 string_view)

basic_string

basic_string 은 CharT 타입의 객체들을 메모리에 연속적으로 저장하고, 여러가지 문자열 연산들을 지원해주는 클래스

여러 종류 타입으로 인스턴스화된 문자열 char, wchar_t, char8_t, char16_t, char32_t
basic_sting 문자열들을 어떻게 보관하는지에 대한 로직
Traits 문자열들을 어떻게 연산하는지 에 대한 로직
std::char_traits 사용 시 사용자가 원하는 기능을 가진 문자열을 생성 가능

짧은 문자열 최적화 (SSO)

짧은 길이 문자열의 경우 따로 문자 데이터를 위한 메모리를 할당하는 대신에 그냥 객체 자체에 저장

리터럴 연산자

문자열 리터럴로 정의

std::string operator"" s(const char *str, std::size_t len); std::string str = "hello"; // char[]

C++ 에서 한글 다루기

인코딩(Encoding) 방식 사용 인코딩 방식에 따라 컴퓨터에서 문자를 표현하기 위해 동일하게 4 바이트를 사용하는 대신에, 어떤 문자는 1 바이트, 2 바이트 등의 다른 길이로 저장

인코딩 방식

UTF-8 문자를 최소 1 부터 최대 4 바이트로 표현 즉 문자마다 길이가 다르다!
UTF-16 문자를 2 혹은 4 바이트로 표현
UTF-32 문자를 4 바이트로 표현 메모리 사용량 매우 증가

string_view

문자열을 읽기 만 하는 클래스 어딘가 존재하는 문자열을 참조해서 읽기만 함

메모리 할당 불필요 읽고 있는 문자열의 시작 주소값만 복사
원본 문자열을 수정하지 않는 연산들 사용 가능
불필요한 복사 발생 하지 않음 const char* 과 const string&사이에서 깔끔하게 처리
Undefined behavior 주의 현재 보고 있는 문자열이 소멸된다면 정의되지 않은 작업이 발생 살아 있는 문자열인지 확인이 필요

C++ 템플릿

Tue, 31 May 2022 10:26:42 GMT

*씹어먹는 C++ *

10장 c++ 템플릿 410p-493p

template

원하는 타입으로 대체 되어 사용됨

클래스 템플릿

정의되는 클래스에 대해 템플릿을 정의하고, 템플릿 인자로 T를 받아 해당 타입인 것을 명시 template template

클래스 템플릿 인스턴스화 (class template instantiation) 클래스 템플릿에 인자를 전달해서 실제 코드를 생성하는 것

example code

template 
class Vector {
    T* data;
    int capacity;
    int length;
    public:
    // 생성자
        Vector(int n = 1) : data(new T[n]), capacity(n), length(0) {}
    // 맨 뒤에 새로운 원소를 추가한다.
        void push_back(T s) {
            if (capacity <= length) {
                T* temp = new T[capacity * 2];
                for (int i = 0; i < length; i++) {
                    temp[i] = data[i];
                }
                delete[] data;
                data = temp;
                capacity *= 2;
            }
            data[length] = s;
            length++;
        }
    // 임의의 위치의 원소에 접근한다.
    T operator[](int i) { return data[i]; }
    // x 번째 위치한 원소를 제거한다.
    void remove(int x) {
        for (int i = x + 1; i < length; i++) {
            data[i - 1] = data[i];
        }
        length--;
    }    
    // 현재 벡터의 크기를 구한다.
    int size() { return length; }
        ~Vector() {
        if (data) {
            delete[] data;
        }
    }
};


int main() {
  // int 를 보관하는 벡터를 만든다.
  Vector int_vec;
  int_vec.push_back(3);
  int_vec.push_back(2);

  std::cout << "-------- int vector ----------" << std::endl;
  std::cout << "첫번째 원소 : " << int_vec[0] << std::endl;
  std::cout << "두번째 원소 : " << int_vec[1] << std::endl;

  Vector str_vec;
  str_vec.push_back("hello");
  str_vec.push_back("world");

  std::cout << "-------- std::string vector -------" << std::endl;
  std::cout << "첫번째 원소 : " << str_vec[0] << std::endl;
  std::cout << "두번째 원소 : " << str_vec[1] << std::endl;

-------- int vector ---------- 첫번째 원소 : 3 두번째 원소 : 2 -------- std::string vector ------- 첫번째 원소 : hello 두번째 원소 : world

템플릿 특수화 (template specialization)

특정 경우에 대해서 따로 처리하는 것

템플릿 부분 특수화 시에 반드시 다른 연산자가 붙지 않고 단순한 식별자만 입력해야함

example code

template 
class test {};

template 
class test {};

template <>
class test {};

//전달하는 템플릿 인자가 없어도 특수화를 원할시 template <>
template <>
class Vector {
... // 원하는 코드
}

함수 템플릿 (Function template)

함수 템플릿

원하는 타입을 T로 처리 이후 인스턴스화를 통해 사용 클래스를 인스턴스화 했을 때 와는 다르게 <> 사용하지 않음 들어온 파라미터의 타입을 파악하여 인스턴스

example code

template 
  T max(T& a, T& b) {
  return a > b ? a : b;
}
int main() {
  int a = 1, b = 2;

  std::cout << "Max (" << a << "," << b << ") ? : " << max(a, b) << std::endl;
  std::string s = "hello", t = "world";
  std::cout << "Max (" << s << "," << t << ") ? : " << max(s, t) << std::endl;
}

Max (1,2) ? : 2 Max (hello,world) ? : world

함수 객체(Function Object - Functor)

함수는 아니지만 함수 인 척을 하는 객체

example code


struct Comp1 {
    bool operator()(int a, int b) { return a > b; }
};

struct Comp2 {
    bool operator()(int a, int b) { return a < b; }
};

template 
void bubble_sort(Cont& cont, Comp& comp) {
  for (int i = 0; i < cont.size(); i++) {
    for (int j = i + 1; j < cont.size(); j++) {
    //comp가 객체인데 함수처럼 쓰임
      if (!comp(cont[i], cont[j])) {
      cont.swap(i, j);
      }
    }
  }
}

// 사용 예제

Comp2 comp2;
bubble_sort(int_vec, comp2);

타입이 아닌 템플릿 인자 (non-type template arguments)

하나의 인자로 템플릿을 통해 넘김

템플릿 인자로 전달할 수 있는 타입들
- 정수 타입들 (bool, char, int, long 등등). 당연히 float 과 double 은 제외
- 포인터 타입
- enum 타입
- std::nullptr_t (널 포인터)
컴파일 타입에 값들이 정해져야 하는 것들를 주로 사용
템플릿 인자로 배열의 크기를 명시하여 함수에 배열을 전달할 때 배열의 크기에 대한 정보 확인
의존 타입(dependent type) 템플릿 인자에 따라서 어떠한 타입이 달라질수 있음

example code

template 
T add_num(T t) {
    return t + num;
}

int main() {
  int x = 3;
  std::cout << "x : " << add_num(x) << std::endl;
}

template 의 인자로 T 를 받고, 추가적으로 마치 함수의 인자 처럼 int num 사용

x : 8

디폴트 템플릿 인자

디폴트로 바뀌지 않는 템플릿 인자 = 통해 디폴트 값 지정 template

가변 길이 템플릿

템플릿 파리미터 팩(parameter pack)

0 개 이상의 템플릿 인자들을 가변 길이로 받아 드림

template

템플릿 파라미터 팩과 함수 파라미터 팩의 차이점 템플릿의 경우 타입 앞 에 ... 함수의 경우 타입 뒤 에 ...
sizeof...() 전체 인자의 개수 리턴

example code

template 
void print(T arg) {
    std::cout << arg << std::endl;
}

template 
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);
}

1, 3.1, abc 1, 2, 3, 4, 5, 6, 7

Fold Expression

return (... + nums); 해당 형식을 컴파일러가 아래 처럼 해석 return ((((1 + 4) + 2) + 3) + 10);

단항 좌측 Fold (Unary left fold) 4가지 존재

템플릿 메타 프로그래밍

Template Meta Programming - TMP 타입을 가지고 컴파일 타임에 생성되는 코드로 짜는 프로그래밍

컴파일 타임에 모든 연산이 끝나기 때문에 프로그램 실행 속도를 향상 시킬 수 있다는 장점
템플릿 메타 프로그래밍은 매우 복잡하니 유의
TMP 를 통해서 컴파일 타임에 debugging 가능 (Ex. 단위나 통화 일치 여부등등)
런타임에서 찾아야 하는 오류를 컴파일 타임에서 미리 다 잡을 수 있음
속도가 매우 중요한 프로그램의 경우 TMP 를 통해서 런타임 속도 향상 가능
단위(Unit) 라이브러리 세분화하여 타입을 정의하고 계산할때 TMP사용

example code

 /* 컴파일 타임 팩토리얼 계산 */
#include 

template 
struct Factorial {
    static const int result = N * Factorial::result;
};

template <>
struct Factorial<1> {
    static const int result = 1;
};

int main() {
  std::cout << "6! = 1*2*3*4*5*6 = " << Factorial<6>::result << std::endl;
}

6! = 1*2*3*4*5*6 = 720

Tips

bool 처리

bool 1 bytes < int 4bytes를 bool 32bits로 사용하여 효율적 N 번째 bool 데이터는 N / 32 번째 int에 존재, N % 32 번째 비트

or 연산

특정 비트에만 선택적으로 1로 변환으로 특화 주변 나머지 비트들의 값은 보존하면서 특정 비트만 1

and 연산

원하는 위치의 1 을 AND 하게 되면 해당 비트의 값이 무엇 파악 가능 해당 위치에 있는 비트가 1 일 때 에만 저 값이 0 이 아니게 되고 0 이면 저 값 전체가 0

typedef

자기 자신을 가리키는 타입

using

자기 자신을 가리키는 타입 typedef와 같은 역할로 보다 직관적

typedef Ratio_add rat3;
using rat3 = Ratio_add;

auto 키워드

컴파일러가 타입을 정확히 알아낼 수 있는 경우 굳이 그 길고 긴 타입을 적지 않고 간단히 auto 로 표현

example code


int sum(int a, int b) { return a + b; }

class SomeClass {
  int data;
  public:
    SomeClass(int d) : data(d) {}
    SomeClass(const SomeClass& s) : data(s.data) {}
};

int main() {
  // 함수 리턴 타입으로 부터 int 라고 추측 가능
  auto c = sum(1, 2); 
  // double 로 추측 가능!
  auto num = 1.0 + 2.0;

  // 해당 객체로 추측
  SomeClass some(10);
  auto some2 = some;

  //그냥 int라 추측됨
  auto some3(10); 

    std::cout << "c 의 타입은? :: " << typeid(c).name() << std::endl;
    std::cout << "num 의 타입은? :: " << typeid(num).name() << std::endl;
    std::cout << "some2 의 타입은? :: " << typeid(some2).name() << std::endl;
    std::cout << "some3 의 타입은? :: " << typeid(some3).name() << std::endl;
}

c 의 타입은? :: i num 의 타입은? :: d some2 의 타입은? :: 9SomeClass some3 의 타입은? :: i

클래스 상속 (2)

Tue, 31 May 2022 10:20:45 GMT

*씹어먹는 C++ *

7장 클래스의 상속 298p - 339p

상속의 관계

장점

추상화
특수화
일반화
다형성 하나의 메소드를 호출했음에도 불구하고 여러가지 다른 작업들을 수행

is - a / has - a

is - a / has - a 모든 상속 관계 뒤 바꾸면 성립 안됨 기반 클래스의 모든 기능을 파생 클래스가 포함 파생 is a 기반

up casting

파생 클래스에서 기반 클래스로 캐스팅 하는 것

example code

class Base {
    std::string s;

    public:
        Base() : s("기반") { std::cout << "기반 클래스" << std::endl; }
        void what() { std::cout << s << std::endl; }
};

class Derived : public Base {
    std::string s;

    public:
        Derived() : s("파생"), Base() { std::cout << "파생 클래스" << std::endl; }
        void what() { std::cout << s << std::endl; }
};

int main() {
    Base p;
    Derived c;

    std::cout << "=== 포인터 버전 ===" << std::endl;
    // 포인터 사용
    Base* p_c = &c;
    p_c->what();

    return 0;
}

기반 클래스 기반 클래스 파생 클래스 === 포인터 버전 === 기반

Derived가 Base를 상속 받았으므로
Base 객체를 가리키는 포인터가 Derived c객체를 가리켜도 무방 단 p는 Base 객체를 가르키는 포인터 이므로 Base class에 있는 것만 사용

※ 코드에서 자주 보인다 사용하는 포인터가 뭘 가르키는지 확인 유의

down casting

기반 클래스에서 파생 클래스로 캐스팅 하는 것

하지만 컴파일 에러 발생 static_cast를 사용하여도 런타임 에러 발생

dynamic_cast

부모 클래스의 포인터에서 자식 클래스의 포인터로 다운 캐스팅 해주는 연산자

불가능

부모클래스의 생성자로 생성되었고 부모 포인터가 가리키고 있는 클래스를 자식클래스 포인터로

가능

자식클래스의 생성자로 생성되었고 부모클래스 포인터가 가리키고 있는 클래스를 자식 클래스 포인터로

virtual

가상 함수(virtual function)

런타임시 각 생성된 클래스에 맞는 함수로 실행하게 됨
기반클래스에서 virtual로 정의
파생 클래스의 함수가 기반 클래스의 함수를 오버라이드 하기 위해서는 두 함수의 꼴이 정확히 같아야함
명시적으로 override도 가능 overide 사용
가상 함수를 사용하게 되면 약간의 오버헤드 (overhead) 가 존재

example code


class Base {
    public:
        Base() { std::cout << "기반 클래스" << std::endl; }
        virtual void what() { std::cout << "기반 클래스의 what()" << std::endl; }
};

class Derived : public Base {
    public:
        Derived() : Base() { std::cout << "파생 클래스" << std::endl; }
        void what() { std::cout << "파생 클래스의 what()" << std::endl; }

        /*
        void what() override{ std::cout << "파생 클래스의 what()" << std::endl; }
        */
};

int main() {
    Base p;
    Derived c;

    Base* p_c = &c;
    Base* p_p = &p;

    std::cout << " == 실제 객체는 Base == " << std::endl;
    p_p->what();

    std::cout << " == 실제 객체는 Derived == " << std::endl;
    p_c->what();

    return 0;
}

기반 클래스 기반 클래스 파생 클래스 == 실제 객체는 Base == 기반 클래스의 what() == 실제 객체는 Derived == 파생 클래스의 what()

virtual 소멸자

상속 시에, 부모 클래스 소멸자를 가상함수로 만들어야 함

아니면 Parent 포인터로 Child 가리켰을 때 Parent *p = new Child(); child 소멸자가 안 불려서 memory leak 발생

pure virtual function

무엇을 하는지 정의되어 있지 않는 함수 파생 클래스에서 반드시 오버라이딩 되어야만 하는 함수 virtual void func() = 0;

example code

class Animal {
    public:
        Animal() {}
        virtual ~Animal() {}
        virtual void speak() = 0;
};

class Dog : public Animal {
    public:
        Dog() : Animal() {}
        void speak() override { std::cout << "왈왈" << std::endl; }
};

class Cat : public Animal {
    public:
        Cat() : Animal() {}
        void speak() override { std::cout << "야옹야옹" << std::endl; }
};

int main() {
    Animal* dog = new Dog();
    Animal* cat = new Cat();
    dog->speak();
    cat->speak();
}

왈왈 야옹야옹

abstract class

순수 가상 함수를 최소 한개 포함하여 반드시 상속 되어야 하는 클래스

multiple inheritance

다중 상속 한 클래스가 다른 여러 개의 클래스들을 상속 받음

상속 순서에 따라 생성자 호출 순서가 달라짐
기반 클래스들에 겹치는 멤버 변수나 함수가 있으면 구분 불가능 > 에러
다이아몬드 상속(diamond inheritance)주의 > virtual 상속을 통해 해결 가능

example code


class A {
    public:
        int a;
        A() { std::cout << "A 생성자 호출" << std::endl; }
};

class B {
    public:
        int b;
        B() { std::cout << "B 생성자 호출" << std::endl; }
};

class C : public A, public B {
    public:
        int c;
        C() : A(), B() { std::cout << "C 생성자 호출" << std::endl; }
};

int main() { C c; }

A 생성자 호출 B 생성자 호출 C 생성자 호출

class 디자인

브릿지 패턴 N + M 개의 클래스 생성
중접된 일반화 N ×M 개의 파생 클래스 생성
다중 상속 N ×M 개의 파생 클래스 생성

reference

포인터 대신 reference 사용가능

example code

class A {
    public:
        virtual void show() { std::cout << "Parent !" << std::endl; }
};

class B : public A {
    public:
        void show() override { std::cout << "Child !" << std::endl; }
};

void test(A& a) { a.show(); }

int main() {
    A a;
    B b;

    test(a);
    test(b);

    return 0;
}

Parent ! Child !

test함수 래퍼런스로 파라미터를 받아 virtual로 파생클래스의 show함수를 받는다.

클래스 상속 (1)

Mon, 30 May 2022 10:36:28 GMT

*씹어먹는 C++ *

7장 클래스의 상속 270p - 297p

상속(Inheritance)

다른 클래스의 내용을 그대로 포함할 수 있는 작업을 가능하도록 함

상속을 통해 다른 클래스의 정보를 물려 받아서 사용 가능

부모, 자식 클래스/ 기반, 파생 클래스 상속 받는 클래스 : 자식 / 파생

example code - Base / Derived

class Base {
    std::string s;
    public:
        Base() : s("기반") { std::cout << "기반 클래스" << std::endl; }
        void what() { std::cout << s << std::endl; }
};

class Derived : public Base {
    std::string s;
    public:
        Derived() : Base(), s("파생") {
            std::cout << "파생 클래스" << std::endl;
            // Base 에서 what() 을 물려 받았으므로
            // Derived 에서 당연히 호출 가능하다
            what();
        }
};

int main() {
    std::cout << " === 기반 클래스 생성 ===" <<         std::endl;
    Base p;
    std::cout << " === 파생 클래스 생성 ===" <<         std::endl;
    Derived c;
    return 0;
}

=== 기반 클래스 생성 === 기반 클래스 === 파생 클래스 생성 === 기반 클래스 파생 클래스 기반

Derived 생성자는 초기화 리스트에서 기반의 생성자를 호출해서 기반의 생성을 먼저 처리
- 파생 클래스 가 출력하기 이전에 Base 의 생성자가 호출되어서 기반 클래스 가 먼저 출력
What()
- Base 의 모든 정보를 상속 받았기 때문에 Derived 에서도 what() 호출 가능
- 만약 Derived에서 what을 동일하게 정의해 준다면 Derived what()이 Base what()을 오버라이딩 되어 Derived what()이 호출 되어 '파생'이 출력 됨

protected

접근 지시자 protected

상속받는 클래스에서는 접근 가능하고 그 외의 기타 정보는 접근 불가능

protected 외부에서 접근 불가능. 단, 상속 받으면 가능
private 외부에서 접근 불가능. 자기 자신 class만 가능
public 외부에서 접근 가능

class 상속 접근 지시자

class A : public(접근 지시자) B

public 상속 기반 클래스의 접근 지시자들에 영향 없이 그대로 작동
protected 상속 public 은 protected로 바뀜 나머지는 그대로 유지
private 상속 모든 접근 지시자들이 private으로 바뀜

연산자 오버로딩 & friend & C++ 스타일의 캐스팅

Fri, 27 May 2022 10:12:56 GMT

*씹어먹는 C++ *

6장 연산자 오버로딩(overloading) 188p - 269p

대표적 연산자

+, -, * 와 같은 산술 연산자
+=, -= 와 같은 축약형 연산자
>=, == 와 같은 비교 연산자
&&, || 와 같은 논리 연산자
-> 나 * 와 같은 멤버 선택 연산자 (역참조 연산자)
++, -- 증감 연산자
[ ] 배열 연산자 와 () 함수 호출 연산자
= 대입 연산자

연산자 오버로딩(overloading)

연산자 오버로딩

기본 연산자들을 직접 사용자가 정의 사용

C++에서는 사용자 정의 연산자 사용 가능
- 클래스 내부 or 전역 함수도 가능
※이항 연산자 (피연산자를 두개 취하는 연산자) 주의
기본적이 format (리턴 타입) operator(연산자) (연산자가 받는 인자)

example code

// == 
bool MyString::operator==(MyString& str) {
  return !compare(str); // str 과 같으면 compare 에서 0 을 리턴한다.
}
// << 
std::ostream& operator<<(
    std::ostream& os, const Complex& c) { os << "( " << c.real << " , " << c.img << " ) "; 
      return os;
}
// +
Complex operator+(const Complex& a, const Complex& b) {
  Complex temp(a.real + b.real, a.img + b.img);
  return temp;
}
// []
char& MyString::operator[](const int index) { return string_content[index]; }

주요 포인트
• 두 개의 동등한 객체 사이에서의 이항 연산자는 멤버 함수가 아닌 외부 함수로 오버로딩 하는 것이 좋음 • 두 개의 객체 사이의 이항 연산자 이지만 값의 변화가 동등하지 않는 이항 연산자는 멤버 함수로 오버로딩 하는 것이 좋음 • 단항 연산자는 멤버 함수로 오버로딩 하는 것이 좋음 • 일부 연산자들은 반드시 멤버 함수로만 오버로딩 해야함

타입 변환 연산자

사용자 정의 객체를 다른 자료형의 변수에 대입 하고자 사용

기본적인 format operator (변환 하고자 하는 타입) ()

example code

#include 
class Int {
    int data;
    // some other data
    public:
        Int(int data) : data(data) {}
        Int(const Int& i) : data(i.data) {}
        operator int() { return data; }
};
int main() {
    Int x = 3;
    int a = x + 4;

    x = a * 2 + x + 4;
    std::cout << x << std::endl;
}

friend

클래스나 함수에서 friend로 선언된 다른 클래스의 private 및 protected 멤버에 접근

클래스 private 인 경우 접근 불허 그러나 필요의 경우 해당 클래스나 함수에서 접근 가능하기 위해 사용

참고 : https://genesis8.tistory.com/98

friend 클래스

class 전체를 public으로 접근 가능 friend를 선언한 class에 해당 class에서 지정한 class가 접근가능

example code

class A{
public:
    A(){a=0;}
    friend B;
private:
    int a=0;
};

// class B에서 A의 private 접근 가능 
class B{
public:
    B(){b=0;}
    void print(A& classa){
        cout<< classa.a<


friend 맴버 함수
class 전체가 아닌 class의 특정 멤버 함수만 friend로 선언 
friend를 선언한 class에 해당 class에서 지정한 class의 멤버 함수만 접근가능
class A{
public:
    A(){a=0;}
    friend void B::print(A% classa);
private:
    int a=0;
};

// class B에서 A의 private 접근 가능 
class B{
public:
    B(){b=0;}
    void print(A& classa){
        cout<< classa.a<

friend 전역 함수
접근 지정자를 무시하고 클래스 내부의 멤버에 접근

class B{
public:
    B(){b=0;}
private:
    int b=0;
    friend void print(B& classb){
        cout<< classb.b<

C++ 스타일의 캐스팅
4가지 종류

static_cast
  우리가 흔히 생각하는, 언어적 차원에서 지원하는 일반적인 타입 변환
const_cast
  객체의 상수성(const) 를 없애는 타입 변환. 쉽게 말해 const int 가 int로 바뀜
dynamic_cast 
  파생 클래스 사이에서의 다운 캐스팅
reinterpret_cast
  위험을 감수하고 하는 캐스팅으로 서로 관련이 없는 포인터들 사이의 캐스팅

※ 생각보다 우리 코드에서 자주 보인다 알아두자
기본적인 format
(원하는 캐스팅 종류)<바꾸려는 타입>(무엇을 바꿀 것인가?)
example code
//static_cast 로 float 타입의 float_variable -> int 타입 변환
static_cast(float_variable);



C++ 객체 지향 프로그래밍(oop)
Wed, 18 May 2022 08:20:51 GMT
*씹어먹는 C++ *
5장 객체지향 프로그래밍(oop) 57p - 187p

객체 지향 언어
object oriented language

추상화 ( Abstraction ) 

=> 컴퓨터에서 처리 할 수 있도록 현실 세계를 반영하여 함수와 변수화 

캡슐화 ( Encapsulation)

=> 변수들을 외부로 보호 
=> 객체의 인스턴스 변수의 값은 인스턴수 함수를 통해서 변경 ( 간접적으로 조절 )

* 사용 이유
 
=> 객채 내부적인 처리는 알 필요 없도록 함
=> 복잡한 객채의 일들을 내부에서 처리 


객체

object
variale + method 
=> 변수 + 함수 
객체에 정의 되면 
=> instance variable + instance method 
변수들과 참고 자료들로 이루어진 소프트웨어 덩이리
클래스

class
객체를 만들기 위한 뼈대 이자 설계도 
클래스
=> member variale + member method 
c++에서 클래스를 이용해 만들어진 메모리에 객체 => instance
Example code 
include 

class Animal {
  private:
    int food;
    int weight;
  public:
    void set_animal(int _food, int _weight) {
    food = _food;
    weight = _weight;
    }
    void increase_food(int inc) {
    food += inc;
    weight += (inc / 3);
    }
    void view_stat() {
    std::cout << "이 동물의 food : " << food <<     std::endl;
    std::cout << "이 동물의 weight : " << weight <<     std::endl;
    }
}; // 세미콜론 잊지 말자!

int main() {
    Animal animal;
    animal.set_animal(100, 50);
    animal.increase_food(30);
    animal.view_stat();
    return 0;
}

클래스 인스턴스 생성
클래스 이름으로 명시
class 접근 지시자
외부에서의 접근 
가능 public
불가능 private < 객체내 보호를 위해 내부에서만 접근 가능
* protected < 상속인 경우에만 접근 가능 

키워드 명시 없다면 private으로 설정 
맴버 함수
해당 class 내 멤버 변수는 명시 없시 사용 가능 
함수의 오버로딩
Overloading
함수의 이름이 같더라도 인자가 다르면 다른 함수라고 판단 
example code 
#include 

void print(int x) { std::cout << "int : " << x << std::endl; }
void print(double x) { std::cout << "double : " << x << std::endl; }

int main() {
    int a = 1;
    char b = 'c';
    double c = 3.2f;

    print(a);
    print(b);
    print(c);

    return 0;

int : 1
int : 99 // char가 아니라 int
double : 3.2

c++ 컴파일러 처리

자신과 타입이 정확히 일치 함수 찾기
정확히 일치하는 타입이 없는 경우 비슷한 형변환을 통해 일치하는 함수 찾기
없다면 더 포괄적인 형변환을 통해 일치하는 함수 찾기
유저 정의된 타입 변환으로 일치하는 것 찾기

if)  그래도 없다면 or 두 개 이상 같으면 error: ambiguous
생성자 및 소멸자
constructor
객체 생성시 자동으로 호출되는 함수 > 객체를 초기화 해주는 역할 
// 객체를 초기화 하는 역할을 하기 때문에 리턴값이 없다!
/* 클래스 이름 */ (/* 인자 */) {}
인자에 맞춰 생성자를 호출하여 객체를 생성
example code
//생성자
Date(int year, int month, int day)

//객체 생성
Date day(2011, 3, 1); // 암시적 방법 (implicit)
Date day = Date(2012, 3, 1); // 명시적 방법 (explicit)

default constructor
디폴트 생성자
생성자 정의를 하지 않아도 컴파일러가 자동으로 추가하여 디폴트 생성자를 호출 
인자를 하나도 가지지 않는 생성자 
example code 
//디폴트 생성자 정의
Date() {
    year = 2012;
    month = 7;
    day = 12;
}
//객체 선언
Date day = Date();
Date day2;
//객제가 아니라 하나의 함수로 인식 됨 *주의*
Date day3(); 

//명시적으로 디폴트 생성자 사용 
class Test {
  public:
    Test() = default; // 디폴트 생성자를 정의해라
};
생성자 오버로딩
디폴트 생성자 제외하고 다른 인자들을 갖는 생성자 정의하여 생성자 오버로딩 
클래스의 객체를 여러가지 인자타입으로 초기화 하여 객체 생성 가능 
소멸자
Destructor
객체가 소멸 될 때 자동으로 호출 되는 함수 
메모리 누수 방지로 동적 할당 delete 할 수 있도록 한다.

default destructor
소멸자가 필요 없다면 구지 적지 않아도 컴파일러가 생성 

메모리 누수
객체내 동적할당 시 객체가 delete된 후 지워질 수 없어 
메모리 공간에 쌓이며 필요없는 메모리 점유를 하게 된다. 

소멸자가 불리는 순서 주의 
전역 객체는 전체 프로그램 종료할 때 호출 
지역 객체는 해당 지역이 없어질 때 호출


example code 
// 소멸자
~(클래스의 이름)

Marine::~Marine() {
    std::cout << name << " 의 소멸자 호출 ! " <<         std::endl;
    if (name != NULL) {
    delete[] name;
    }
}
복사 생성자
copy constructor
class T 의 객체 a 를 상수 레퍼런스로 받아 복사 하여 객체 생성 
const이므로 내부에서 a 데이터 변경은 불가능
새로운 인스턴스 변수 초기화시 데이터 복사하여 사용 

Default copy constructor
c++ 컴파일러에서 지원 
대응 되는 원소를 1 대 1로 복사

깊은 복사 /얕은 복사
깊은 복사
메모리를 새로 할당해서 내용 복사
얕은 복사
단순히 대입만 해서 복사
깊은 복사를 원할 때는 사용자가 직접 복사 생성자 정의 



example code
// class T에서 복사 생성자
// T(const T& a);

Photon_Cannon::Photon_Cannon(const Photon_Cannon& pc) {
    std::cout << "복사 생성자 호출 !" << std::endl;
    hp = pc.hp;
    shield = pc.shield;
    coord_x = pc.coord_x;
    coord_y = pc.coord_y;
    damage = pc.damage;

    //깊은 복사
    name = new char[strlen(pc.name) + 1];
    strcpy(name, pc.name);
}

//복사 생성자를 이용한 객체 생성 
Photon_Cannon pc1(3, 3);
Photon_Cannon pc2(pc1);
// '=' 이용한 복사 생성자 호출
Photon_Cannon pc3 = pc2;

생성자 초기화 리스트
initializer list
생성자를 호출하는 동시에 멤버 변수를 초기화

초기화 리스 사용 안 할 시
생성 먼저한 후 대입 수행 < 초기화 리스트가 효율적

const
멤버 변수 정의를 const하여 초기화 후 변경 불가능 


example code 
// 초기화 리스트
// (생성자 이름) : var1(arg1), var2(arg2) {}

Marine::Marine(int coord_x, int coord_y)
: coord_x(coord_x), coord_y(coord_y), hp(50), damage(5), is_dead(false) {}

static
static 변수
클래스 하나에만 종속되는 변수
어떤 클래스의 static 멤버 변수는 프로그램이 종료 될때 소멸 
클래스의 모든 객체들이 공유 하는 하나의 변수

static 변수 초기화
클래스 내부에서는 불가능
클래스 외부에서 초기화 가능 
const static 변수일때만 내부에서 초기화 가능 
static 변수 관리
주로 생성자와 소멸자에 추가해서 사용int Marine::total_marine_num = 0;


static 함수
객체가 없어도 그냥 클래스 자체에서 호출
클래스 전체에 딱 1 개 존재하는 함수
내부에 그냥 클래스의 멤버 변수들을 이용 불가능< 객체를 지정하지 않으므로
example code
// class 내 함수 선언
static void show_total_marine();

//함수 정의
void Marine::show_total_marine() {
    std::cout << "전체 마린 수 : " << total_marine_num << std::endl;
}
//함수 사용시 class:: (static 함수)형식으로 사용
Marine::show_total_marine();
pointer & reference in class
this
호출하는 객체 자신을 가리키는 포인터
static 함수를 제외한 모든 멤버 함수에 정의 되어 있다
example code
Marine& Marine::be_attacked(int damage_earn) {
    hp -= damage_earn;
    if (hp <= 0) is_dead = true;
    return *this;
}
레퍼런스를 리턴하는 함수



c++ 참조자 레퍼런스
Tue, 17 May 2022 09:15:13 GMT
*씹어먹는 C++ *
3장 c++ 참조자 래퍼런스 30p ~ 46p

Pointer & reference
Difference between pointer and reference






diff
pointer
reference








사용법
*( 변수이름 )
( 타입 )&



or ( 타입 )*
or &( 변수이름 )


개념
주소값 저장
별명으로 해당 주소값 사용


사용 이유

불필요한 &, * 사용이 줄어듦


정의 시
변수 명시 불필요
반드시 변수 명시


참조 변경
다른 주소값으로 가능
변경 불가능


메모리 할당
공간 할당
컴파일러 구현에 따라 다름


배열 생성
가능
불가능













reference
함수 인자로 받기
실제 변수를 넘기는 것과 같다
int change_val(int &p) {
p = 3;
return 0;
}

int main() {
int number = 5;
std::cout << number << std::endl;
change_val(number);
std::cout << number << std::endl;
}

result
5
3

상수 참조 불가능
원한다면  const 사용
// do not use 
int &ref = 4;

// use
const int &ref = 4;

레퍼런스 배열 불가능
메모리 상 존재하지 않을 수 있으므로 

하지만 배열의 레퍼런스 생성은 가능 
포인터와 다르게 반드시 크기 명시 
int arr[3] = {1, 2, 3};
int(&ref)[3] = arr; // refenence 크기 반드시 명시
ref[0] = 2;
ref[1] = 3;
ref[2] = 1;
레퍼러스 리턴 (※주의※ Dangling reference)
함수 사용시 지역변수 레퍼런스를 리턴하게 되면 함수 종료 후 사라지기 때문에 reference가 참조 할 것이 사라지게 된다.

오류를 피하기 위해 이왕이면 
외부 변수 레퍼런스로 리턴 하자 
만약 다른 타입으로 return 하고 레퍼런스로 받는 다면 컴파일 오류가 발생한다. 
const를 사용하면 가능 하나 사라지기 전까지만 사용 가능 하다.



CPP 스터디
Tue, 10 May 2022 09:21:36 GMT

    



참고 교재
"씹어 먹는 C++" 

Start : 22.05.16
End : 22.07.12
Every Tuesday 7pm.
Study with tera_geniel, pesu1027, j2013yk

주차별 스터디 내용
0주차
스터디 규칙 상세 결정 및 컨펌, 피드백
1주차
3장 c++ 참조자 래퍼런스 30p ~ 46p
5장 객체지향 프로그래밍(oop) 57p - 187p
2주차
6장 연산자 오버로딩(overloading) 188p - 269p
7장 클래스의 상속 270p - 297p
3주차
7장 클래스의 상속 298p - 339p
10장 c++ 템플릿 410p-493p
4주차
11장 c++ 표준 라이브러리(stl) 494p-555p
11장-3, 11장-4 556p - 612p
5주차
12장 c++에서의 예외 처리 613p-629p
13장 우측값과 이동 연산 630p-648p
6주차
13장 우측값과 이동 연산 649p-670p
14장 스마트 포인터 671p-704p
15장 함수 객체 705p-718p
7주차
16장 C++ 쓰레드 719p-825p
8주차
실제로 코드 짜보며 공부하기

diff	pointer	reference

사용법	`*`( 변수이름 )	( 타입 )&
	or ( 타입 )`*`	or &( 변수이름 )
개념	주소값 저장	별명으로 해당 주소값 사용
사용 이유		불필요한 &, `*` 사용이 줄어듦
정의 시	변수 명시 불필요	반드시 변수 명시
참조 변경	다른 주소값으로 가능	변경 불가능
메모리 할당	공간 할당	컴파일러 구현에 따라 다름
배열 생성	가능	불가능