쁠달자

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

• 나종우
  
• 주영석
  
• 조예진
  
  

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

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

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

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만 지정
  

  
  

• 전처리기 : 컴파일 이전에 전처리문에 따라 소스를 수정한다. (일종의 문서 편집)
  
  
• 매크로 함수는 단순 치환으로 작동하기 때문에, 함수 호출 과정이 없어 속도가 빠를 수도 있다.
  다만 단순 치환이라서, 인자로 수식 등을 넣으면 오작동할 수 있기 때문에 괄호로 감싸줘야 한다.
  현대 스타일에서는 잘 사용하지 않는다. 디버깅에 어려움이 있다.
  

  // #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"
  

  
  

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

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

• 암시적 형변환 (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 속성 변환
  

  
  

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

  
  

• 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>>;
  
• 주의사항 : 블럭 안에 선언된 문장은 블럭 안에서만 효력 있음
  
  

• 구조체는 여러 연관된 멤버를 포함하는 일종의 사용자 정의 자료형
  
• 중요 특징 : 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;
  }
  

  
  

사용자는 언제나 프로그래머가 원치 않는 입력을 넣기 때문에 유효성 검사 및 예외 처리를 잘 해줘야 한다.
반복문과 조건문을 활용해 올바른 입력을 받도록 처리하자. 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');
}

• 정적 할당 : 컴파일 타임에 크기가 결정되고, 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;

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로 읽으면 의미를 파악할 수 있다. (추가설명)
  
  • ex) const int *const ptr : const pointer to int const (int const는 const int와 같은 의미이다)
    
    

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

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