쁠달자

프로그램(어플리케이션, 소프트웨어)를 만들기 위한 언어
저수준 언어 (기계와 가깝고 세부적으로 조작) : 기계어, 어셈블리어 등
고수준 언어 (인간에 가깝고 추상화된 구조) : 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;
}

No older revisions available