E D R , A S I H C RSS

쁠달자

1. 소개

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

3. 활동

3.1. 20181224

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

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

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

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

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

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

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

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

3.2. 20181226

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

  • 매크로 함수는 단순 치환으로 작동하기 때문에, 함수 호출 과정이 없어 속도가 빠를 수도 있다.
    다만 단순 치환이라서, 인자로 수식 등을 넣으면 오작동할 수 있기 때문에 괄호로 감싸줘야 한다.
    현대 스타일에서는 잘 사용하지 않는다. 디버깅에 어려움이 있다.
    // #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
    

3.2.2. 기본 자료형 소개
  • 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)
    

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

3.2.4. 전역 변수, 정적 변수, 내부 연결, 외부 연결
  • 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"
    

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

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

3.2.7. 형변환 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 속성 변환
    

3.2.8. 문자열 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;
    }
    

3.3. 20181228

3.3.1. 열거형 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;
    }
    

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

3.3.3. 구조체 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;
    }
    

3.3.4. 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');
}

3.3.5. 메모리 동적 할당 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;
    }
    

3.3.6. 동적 할당 배열
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;

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

3.3.8. 참조 변수 reference variable
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;
}

3.4. 20190107

Valid XHTML 1.0! Valid CSS! powered by MoniWiki
last modified 2019-01-08 04:41:29
Processing time 0.0989 sec