imported>Unknown at 14:07, 16 February 2021

2021-02-16T14:07:51Z

New page

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

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

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

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

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

===== 입출력 스트림과의 첫 만남 cin, cout =====
cin, cout : 대부분의 자료형 입출력 가능, 포인터 쓸 필요 X
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 =====
#
const int *ptr
: const int에 대한 포인터. ptr이 저장하는 주소값을 변경하는건 가능, 가리키는 변수의 값을 바꾸는 것은 불가능
#
int *const ptr
: int에 대한 const 포인터. 가리키는 변수의 값을 바꾸는 것은 가능, ptr이 저장하는 주소값을 변경하는건 불가능
#
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 =====
# C++의 참조 변수는 다른 변수를 참조할 때 사용한다. (포인터와 비슷)
# 참조 변수는 선언과 동시에 초기화(참조)가 반드시 되어야 하며, 참조하는 대상을 다른 대상으로 바꿀 수 없다.
# 참조 변수는 별명을 붙이는 것이라 생각하면 된다. 기존 변수에 또 다른 이름을 하나 부여하는 것이다.
# 참조 변수는 일종의 별명이기 때문에 일반 변수와 같은 방식으로 사용할 수 있다.
# 참조 변수를 초기화할 때 참조 가능한 대상이 들어와야 하지만, const 참조 변수의 경우 리터럴로 초기화할 수 있다.
# 참조 변수는 주로 함수 매개 변수로 많이 사용한다. (복사 과정이 없어 속도가 빠르다)
# [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 ====

쁠달자 - Revision history

imported>Unknown at 14:07, 16 February 2021