[[TableOfContents]]
=== 소개 ===
 * 쁠달자 (C에 +를 달자 ~~학점에도 쁠을~~)
 * C++ 입문 스터디, 그러나 심도있게 진행
 * [https://www.inflearn.com/course/following-c-plus/ 홍정모의 따라하며 배우는 C++]를 공부합니다.
 * 미리 강의를 듣고 스터디날에 의견을 나누며 요약 정리 및 복습하는 방식으로 진행합니다.
 * 이미 알고 있는 내용(C언어 내용)은 적당히 스킵합니다.
 * 일정 : 월수금 3시 ~ 종료 시간 미정 (대략 2시간)

=== 참가자 ===
 * [나종우]
 * [주영석]
 * [조예진]

=== 활동 ===
==== 20181224 ====
===== C++ 꼭 공부해야 할까? =====
1. C++로 프로그래밍 기반을 다지기 좋다 (기반이 있어야 응용까지 가능)
2. 예제를 풀면서 발생하는 문제를 해결하면서 실력이 증가
3. C++은 다른 언어를 배울때도 빠르게 익힐 수 있게 도와준다.

===== 프로그래밍 언어란 =====
 * 프로그램(어플리케이션, 소프트웨어)를 만들기 위한 언어
 * 저수준 언어 (기계와 가깝고 세부적으로 조작) : 기계어, 어셈블리어 등
 * 고수준 언어 (인간에 가깝고 추상화된 구조) : C, C++, Python, Java 등
   * 컴파일러 언어 : 코드 → 컴파일러 → 실행파일 → CPU (실행속도 빠름)
   * 인터프리터 언어 : 스크립트 → 인터프리터 → CPU (실행파일 X, 실행속도 느림)
 * 이식성

===== C, C++ 언어 소개 =====
 * 창시자 : C - 데니스 리치, C++ - 비야네 스트롭스트룹
 * C++ 설계 철학 : 프로그래머를 믿어라
   * 실용성, 스타일의 자유, 오용보다 다기능 중점, 명확하게 명시, C++ 아래에 다른 언어 없다

===== 입출력 스트림과의 첫 만남 cin, cout =====
cin, cout : 대부분의 자료형 입출력 가능, 포인터 쓸 필요 X
{{{using namespace std; // 네임스페이스 생략 가능, std::cin → cin
std::cin >> 변수1 >> 변수2 >> ...;
std::cout << "문자열" << '문자' << 변수 << ... << std::endl; // endl : 줄바꿈
// <<와 >>는 스트림이 흘러가는 방향으로 기억하자 }}}

===== 선언과 정의의 분리 =====
 * 선언(declaration) : 최소 형태로 대상의 존재를 컴파일러에게 알려주는 것 (여러개 존재 가능)
 * 정의(definition) : 대상의 세부적인 실제 구현 사항 (하나만 있어야 함)
 * 컴파일러는 소스를 위에서 아래로 읽기 때문에 선언이 필요하다.
 * 함수의 선언과 정의를 분리하자. 함수를 사용하기 전에 선언을 한다. (전방 선언)

===== 헤더파일 만들기 =====
 * 파일을 분리하는게 좋은 습관 (프로젝트가 커지면 꼭 필요)
 * 헤더파일에 선언, 소스파일에 정의
 * 함수 등을 사용할 곳에서 필요한 헤더파일을 include

===== 헤더 가드가 필요한 이유 =====
 * 헤더 가드 : 중복 include를 방지 (#pragma once)
 * 표준 방식대로는 #ifndef #define ~ #endif 식으로 구현

===== 네임스페이스 (명칭 공간) =====
 * namespace : 함수나 변수 등에 특정 공간을 부여하여 서로 겹치는 것을 방지
 * 중첩하여 사용하는 것도 가능하다.
 * 범위 지정 연산자(::)를 이용해 접근하지만, using 문을 쓰면 생략 가능{{{
namespace MySpace {
    namespace InnerSpace {
        void myFunction() { }
    }
    void myFunction() {
       //...
    }
}

MySpace::myFunction();
MySpace::InnerSpace::myFunction();

// 네임스페이스 생략 방법
// using namespace MySpace; → MySpace에 속한 모든 대상
// using MySpace::myFunction; → myFunction만 지정
}}}

==== 20181226 ====
===== 전처리기와의 첫 만남 =====
 * 전처리기 : 컴파일 이전에 전처리문에 따라 소스를 수정한다. (일종의 문서 편집)

 * 매크로 함수는 단순 치환으로 작동하기 때문에, 함수 호출 과정이 없어 속도가 빠를 수도 있다.
   다만 단순 치환이라서, 인자로 수식 등을 넣으면 오작동할 수 있기 때문에 괄호로 감싸줘야 한다.
   현대 스타일에서는 잘 사용하지 않는다. 디버깅에 어려움이 있다.{{{
// #define은 단순 치환 기능 (단, 전처리문 안에서는 치환하지 않음)
#define MAX(x,y) (((x)>(y))?(x):(y)) // 매크로 함수, 비슷한 기능의 std::max가 있음
#define MY_NUMBER 123123 // 매크로 상수

// 조건부 컴파일 (멀티 플랫폼 프로그래밍 등)
#define MY_PLATFORM
#ifdef MY_PLATFORM
  int num = 1; // 여기서는 이게 컴파일 됨
#else
  int num = 2;
#endif
}}}

===== 기본 자료형 소개 =====
 * bool : 참(true), 거짓(false) - 1바이트
 * nullptr (C++11) : 널포인터, 가리키는 대상이 없음을 표현 (NULL과 비슷하지만 NULL은 정수임)
 * auto (C++11) : 컴파일 타임에 자동으로 자료형을 추론하여 정해줌

 * C++에서는 변수를 어느 곳에든 선언할 수 있다 (C언어는 블럭 첫부분에만 선언 가능)
 * 변수 초기화 방법{{{
copy initialization : int a=1.23; // OK
direct initialization : int b(4.56); // OK
uniform initialization (C++11) : int c{7.89}; // error (축소 변환 X)
}}}

===== 지역 변수, 범위, 지속기간 =====
 * local variable : 어느 지역(블록)에 속하고, 범위를 벗어나면 접근 불가능한 변수 (스택 사용)
 * scope, duration : 정의 ~ 블록(중괄호)의 끝
 * static local variable은 예외임 (프로그램 종료시까지 지속되고, 데이터 영역 사용)
 * variable shadowing : 같은 이름의 변수를 사용할때, 좁은 범위의 변수를 사용함

===== 전역 변수, 정적 변수, 내부 연결, 외부 연결 =====
 * global variable : 프로그램 전체에서 접근 가능 (데이터 영역 사용)
 * static variable : 일정 범위에서 접근 가능 (데이터 영역 사용)
 * global과 static의 duration : 정의 ~ 프로그램 종료
 * internal linkage : 한 파일 안에서만 연결 (static, const) - const는 정의된 곳에서 extern 사용시 외부 연결 가능
 * external linkage : 다른 파일로도 연결 (일반적인 전역 변수){{{
[일반적인 전역 변수, 함수 사용법]

<ABC.cpp>
#include "ABC.h"
int x = 5; // 정의
int something() { return 1; } // 정의

<ABC.h>
extern int x; // 선언, external linkage 요청
int something(); // 선언, 함수는 기본적으로 external이므로 extern 생략

// 필요한 곳에서 #include "ABC.h"
}}}

===== Using문과 모호성 =====
 * 겹치지 말라고 만든 namespace를 using으로 막 생략하다 보면 모호성이 발생
   * ex) using namespace std; 를 하면 변수 이름으로 count 사용 불가
 * 해결법
   * 범위 지정 연산자(::)를 사용
   * namespace 전체가 아닌 원하는 대상만 생략하기 (using std::cout)
   * 좁은 범위(블록)에서 using 문 사용

===== auto 키워드와 자료형 추론 (C++11) =====
 * auto 변수를 쓸 때는 초기화가 필수 (초기화를 안 하면 자료형 추론 불가능)
 * 함수 반환형으로 auto를 쓸 수 있음 (반환값의 형식이 일정해야 됨)
 * 함수 매개변수에는 auto 사용 불가능 (나중에 배울 template를 쓰자)

===== 형변환 Type conversion =====
 * 암시적 형변환 (implicit type casting) : 형변환을 직접 쓰지도 않았는데 컴파일러가 알아서 형변환
   * 우선 순위 : 실수 > 바이트 수 > unsigned
 * 명시적 형변환 (explicit type casting)
   * int x = (int)3.14; // C-Style, 강제 형변환
 * C++ Style Casts{{{
static_cast : [컴파일 타임에 오류 검사] C-Style과 비슷하지만 타입 오류를 잡아준다. 가장 많이 사용 
dynamic_cast : [실행 중에 오류 검사] 다운캐스팅(부모 → 자식)에 사용 (객체지향 내용)
reinterpret_cast : 비트열을 변경하지 않고 그저 타입만 변경(재해석) (정수-포인터, 포인터-포인터 변환에 사용)
const_cast : const 속성 변환
}}}

===== 문자열 std::string 소개 =====
 * C의 char 배열을 대체하는 매우 편리한 문자열 사용 방법
 * 클래스로 구현되어 있음 (객체지향 내용){{{
#include <iostream>
#include <string> // string 클래스 존재
using namespace std;

int main() {
  string name = "Jack Jack";
  cout << name << endl;

  int age = 0;
  cout << "Your age : ";
  cin >> age; // cin은 버퍼에 whitespace(\n, \t, ' ')를 남김
  cin.ignore(32767, '\n'); // 따라서 버퍼에서 \n을 제거해야 getline이 정상적으로 동작
  
  cout << "Your name : ";
  getline(cin, name); // getline은 버퍼에서 \n 이전까지 입력받고, \n은 버퍼에서 제거
  cout << name << ':' << age << endl;

  string a = "Hello ", b = "world";
  string c = a + b; // append
  cout << c << endl;

  for (int i = 0; i < c.size(); i++) {
    cout << c[i] << c.at(i) << endl; // index로 접근
  }

  // compare
  if (c == "Hello world") {
    cout << "Hi!\n";
  }
  
  return 0;
}
}}}

==== 20181228 ====
===== 열거형 enumerated types =====
 * enum : 정수를 기호화하여 의미 부여가 되고 기억하기 쉽고 유지보수에도 좋다
 * 주의사항 : 식별자(identifier)가 겹치면 안 됨{{{
enum Color {
  // 매크로와 비슷하게 주로 대문자로 쓴다
  COLOR_BLACK,       // 0
  COLOR_RED,         // 1
  COLOR_BLUE,        // 2
  COLOR_GREEN = 7,   // 7
  COLOR_SKYBLUE,     // 8
  COLOR_ORANGE       // 9
};

int main() {
  Color myColor = COLOR_RED; // 열거형 변수 사용 (C언어는 enum Color myColor로 선언해야 됨)
  // Color myColor2 = 1; (error, 열거형 변수에 정수 직접 대입 불가능)
  int myColor3 = COLOR_RED, myColor4 = myColor; // 정수형 변수에 열거형을 대입할 수는 있음

  if (myColor4 == COLOR_RED) {
    // ok
  }
  return 0;
}
}}}

===== 자료형에게 가명 붙여주기 =====
  * 장점 : 자료형에 나만의 의미 부여 가능, 긴 자료형 축약 가능, 유지보수에 좋음
  * typedef : {{{typedef std::vector<std::pair<std::string,int>> pairlist_t;}}}
  * using (C++11) : {{{using pairlist_t = std::vector<std::pair<std::string,int>>;}}}
  * 주의사항 : 블럭 안에 선언된 문장은 블럭 안에서만 효력 있음

===== 구조체 struct =====
  * 구조체는 여러 연관된 멤버를 포함하는 일종의 사용자 정의 자료형
  * 중요 특징 : C++의 구조체에는 함수를 넣을 수 있음
  * C++의 구조체는 C언어의 구조체와 많이 다르고, class에 가깝다 (기본 접근 제한자가 public인 class)
  * 미세팁 : sizeof로 구조체의 크기를 구하면 예상보다 클 수 있다. 빠른 처리를 위해 padding이 들어가서 그렇다.{{{
#include <iostream>
#include <string>
using namespace std;

struct Person {
    // 멤버 변수
    double height;
    float  weight = 100.0f; // 초기화를 안해주면 default value로 설정
    int    age;
    string name;

    // 멤버 함수
    void print() {
        // 자신의 멤버에 접근할 수 있다
        cout << height << ", "  << weight << ", "
             << age    << ", (" << name   << ')' << endl;
    }
};

struct Family {
    // 구조체 안에 구조체를 넣는 것도 가능
    Person me, mom, dad; // 구조체 변수 사용 (C언어는 struct Person me로 선언해야 됨)
};

Person getMe() {
    // 함수 반환값이 구조체일 수도 있다
    Person me{178.5, 50.0, 20, "Jack Jack"}; // uniform initialization으로 편하게 초기화
    return me;
}

int main() {
    Person me_from_func = getMe();
    Person me2;
    me2.print(); // 멤버 선택 연산자를 사용하여 멤버 함수 호출

    // 구조체 간의 대입 (주의 : 기대한 대로 작동이 안 될 수도 있다! 깊은 복사 파트에서 배움)
    me2 = me_from_func;

    me2.print();
    return 0;
}
}}}

===== std::cin 더 잘 쓰기 =====
사용자는 언제나 프로그래머가 원치 않는 입력을 넣기 때문에 유효성 검사 및 예외 처리를 잘 해줘야 한다.
반복문과 조건문을 활용해 올바른 입력을 받도록 처리하자. cin.fail(), cin.clear(), cin.ignore()를 써야 한다.
{{{
int x;
cin >> x;

if (cin.fail()) { // cin의 오류 플래그 반환 (잘못된 입력이 들어왔으면 true 반환)
  // 오류 플래그가 true이면 cin을 쓸 수 없기 때문에 상태 플래그 초기화를 꼭 해줘야 함
  cin.clear(); // cin 상태 플래그 초기화 (주의 : 버퍼 비우기와 관련 없음!)

  // 버퍼 비우기 (\n이 나올때까지 최대 32767문자를 제거)
  cin.ignore(32767, '\n');
}
}}}

===== 메모리 동적 할당 new와 delete =====
 * 정적 할당 : 컴파일 타임에 크기가 결정되고, stack 또는 data 영역에 할당됨 (지금까지 써온 변수)
 * 동적 할당 : 실행 중에 크기가 결정되고, heap 영역에 할당됨
 * C언어의 malloc, free과 비슷하다. 하지만 C++에서는 최대한 new와 delete만 쓰자 (이유는 나중에){{{
int *ptr = new int; // 동적 할당 (실패시 예외(오류) 발생)
delete ptr; // 메모리 해제 (꼭 해줘야 한다! 습관처럼 미리 delete를 써두자)
ptr = nullptr; // dangling pointer 방지

double *ptr2 = new double(3.0); // direct initialization
delete ptr2;
ptr2 = nullptr;

ptr = new int{5}; // uniform initialization
ptr2 = new (std::nothrow) double; // nothrow : 예외를 발생시키지 않음 (실패시 nullptr 반환)
delete ptr;
delete ptr2;
ptr = nullptr;
ptr2 = nullptr;

while (true) {
  // memory leak 발생 (이런 실수를 줄이자)
  int *test = new int;
}
}}}

===== 동적 할당 배열 =====
{{{
int length;
cin >> length; // 배열 크기를 사용자에게 입력받음

int *arr = new int[length]; // 동적 할당 배열 생성
delete[] arr; // 메모리 해제

arr = new int[10](); // 길이가 10인 배열 생성, ()를 붙이면 모두 0으로 초기화
delete[] arr;

// uniform initialization
arr = new int[5]{1, 2, 3}; // {num1, num2, ...} -> 순서대로 num1, num2로 초기화, 남는 곳은 0으로 초기화
delete[] arr;
}}}

===== 포인터와 const =====
1. {{{const int *ptr}}} : const int에 대한 포인터. ptr이 저장하는 주소값을 변경하는건 가능, 가리키는 변수의 값을 바꾸는 것은 불가능
2. {{{int *const ptr}}} : int에 대한 const 포인터. 가리키는 변수의 값을 바꾸는 것은 가능, ptr이 저장하는 주소값을 변경하는건 불가능
3. {{{const int *const ptr}}} : const int에 대한 const 포인터. ptr이 저장하는 주소값 변경 및 가리키는 변수의 값 변경 둘 다 불가능

 * TIP : 거꾸로 읽고, *은 pointer to로 읽으면 의미를 파악할 수 있다. ([https://blog.naver.com/herbbread/220520281357 추가설명])
   * ex) const int *const ptr : const pointer to int const (int const는 const int와 같은 의미이다)

===== 참조 변수 reference variable =====
1. C++의 참조 변수는 다른 변수를 참조할 때 사용한다. (포인터와 비슷)
2. 참조 변수는 선언과 동시에 초기화(참조)가 반드시 되어야 하며, 참조하는 대상을 다른 대상으로 바꿀 수 없다.
3. 참조 변수는 별명을 붙이는 것이라 생각하면 된다. 기존 변수에 또 다른 이름을 하나 부여하는 것이다.
4. 참조 변수는 일종의 별명이기 때문에 일반 변수와 같은 방식으로 사용할 수 있다.
5. 참조 변수를 초기화할 때 참조 가능한 대상이 들어와야 하지만, const 참조 변수의 경우 리터럴로 초기화할 수 있다.
6. 참조 변수는 주로 함수 매개 변수로 많이 사용한다. (복사 과정이 없어 속도가 빠르다)
7. [https://boycoding.tistory.com/207 추가설명]
{{{
#include <iostream>
using namespace std;

void swap(int &x, int &y) {
  int tmp = x;
  x = y;
  y = tmp;
}

void printRef(const int &x) {
  cout << x << endl;
}

int main() {
  int x = 5, y = 20;
  int &ref = x; // 참조 변수
  cout << &x << ' ' << &ref << endl; // x와 ref의 주소값이 같음 (실제로 같은 변수이기 때문에)

  ref = 10;
  cout << x << ' ' << y << ' ' << ref << endl; // 10 20 10 출력

  ref = y;
  ref += 1;
  cout << x << ' ' << y << ' ' << ref << endl; // 21 20 21 출력

  const int &cref = 10; // const 참조 변수는 리터럴로 초기화 가능 (리터럴이 임시변수에 저장됨)
  cout << &cref << ' ' << cref << endl; // 주소값도 있고 값도 제대로 출력

  // int &ref2 = 10; (error, 일반 참조 변수는 l-value로 초기화해야 됨)
  // cref = 30; (error, const 참조 변수는 값 변경 불가능)

  int a = 1, b = 2;
  swap(a, b); // 참조 변수를 활용한 함수 호출
  cout << a << ' ' << b << endl; // 2 1 출력

  printRef(12345); // 매개변수가 const 참조 변수이기 때문에 리터럴을 넣어도 된다.
  return 0;
}
}}}

==== 20190107 ====