Modern C++ Summary (vs. C#)

개인적으로 공부하면서, C#과 같이 사용하면서 헷갈릴 수 있는 부분(C++과 다른 점)과 C++에서 특정 버전 이상에서만 지원하는 문법을 정리한다.

C++ 버전별 주요 특징

- typedef

typedef double my_type_t;
== using my_type_t = double; (C++11 이상)

- enum

enum { };
enum class { }; (C++11 이상)

//c#의 enum과 같이 사용하려면 enum class를 사용한다.
//enum은 스코프를 사용하지 않지만 enum class에서는 C#과 마찬가지로 스코프를 사용한다.

- string

//c++의 string은 std 라이브러리에 포함된다.

//cin으로 문자열을 온전히 받기 위해선
std::getline(std::cin, {변수명})
//이 사용된다.

//cin으로 입력받은 버퍼를 비우기 위해
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
== std::cin.ignore(32767, '\n');
//사용이 필요하다.

- 코드에서 긴급한 탈출 (halt)

HALT → exit(0);

- 랜덤 난수 생성

#include <cstdlib>

std::srand(5323); //5323 = seed → 시드 넘버 지정
std::srand(static_cast<unsigned int>(std::time(0)); // 시간과 연동하여 시드가 계속 변경됨
std::rand();

#include <random> (C++11 이상)

std::random_device rd;
std::mt19937_64 mesenne(rd()); // or mt19937
std::uniform_int_distribution<> dice(1 ,6); // 1~6까지 같은 확률

- cin 활용

# 버퍼 지우기
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
== std::cin.ignore(32767, '\n');

# 입력 범위 문제 확인하기 (둘이 같이 사용됨.)
std::cin.fail(); // return true / false
std::cin.clear(); // 내부 상태 플래그 초기화

- 배열과 포인터

배열을 정의하면 배열의 이름 자체가 주소가 된다.
다만 배열을 함수의 인자로 넘겨, 매개변수로 배열을 받는다면 이 매개변수는 '포인터'로 취급된다.
때문에 매개변수로 받은 배열의 이름(포인터)은 배열의 주소를 저장하는 다른 주소가 된다.
→ 함수에서 이 (배열로 보이지만 포인터 변수인)배열의 sizeof를 찍으면 4바이트(32비트, 64비트에서는 8바이트)로 출력된다. 

- 포인터를 그냥 선언해서는 변수값을 담을 수 없다.
> char *name = "nolda"; (X)
변수값을 담기 위해선 const 선언을 넣으면 사용할 수 있다.
> const char *name = "nolda"; (O)

//참고
(*this).memberValue;
== this->memberValue;

- foreach

C#의 foreach와 사용법은 비슷하지만 문법의 차이가 존재한다.

for (int value : array)
{
}

- 메모리 할당

정적으로 할당된 메모리는 stack에 저장되며, stack은 용량이 작고 컴파일 타임에 크기가 결정된다.
동적으로 할당된 메모리는 Heap에 할당된다. Heap 영역은 런타임에 결정된다.

- Stack / Heap

Memory의 Segment
1. Code - Program
2. BSS - uninitialized data
3. Data - initialized data
4. Stack
 - 로컬 변수, 메인 함수, 메소드 등이 스택으로 쌓임
 - 사이즈가 작기 때문에 Stack Overflow 발생 가능
5. Heap
 - 동적 할당일 경우 Heap 영역에 저장됨

- const와 포인터

int value = 5;
const int *ptr1 = &value; //ptr1에 저장돼있는 주소를 바꾸는건 가능하지만, 주소가 가리키는 value 값을 바꾸는건 안됨
int *const ptr2 = &value; //ptr2에 저장돼있는 주소 값 바꾸는게 안됨
const int *const ptr3 = &value; //주소 값도 바꿀 수 없고 de-referencing으로 값을 바꿀 수도 없음 (다 안됨)

- std::vector

#include <vector>
std::vector<int> array_value;

동적할당 배열에 유용하게 쓰이고 널리 쓰임. C#의 List와 비슷하다.
//size : 사용하는 용량 -> .resize()
//capacity : 총 용량(size에서 가려진 총 용량) -> .reserve

//vector를 stack처럼 사용하기
.push_back();, .pop_back()

- std::tuple

여러 개의 반환 값을 return 시킬 수 있다.

#include <tuple>

std::tuple<int, double> getTuple()
{
	return std::make_tuple(5, 3.14);
}

int main()
{
	std::tuple<int, double> tp = getTuple();
    std::get<0>(tp); //int 값
    std::get<1>(tp); //double 값
    
    //C++17 이상에서는 아래가 가능하다.
    auto[a, b] = getTuple();
}

- 함수포인터

int func() { return 5; }
int func2() { return 9; }

//함수포인터 변수 선언
int(*fcnptr)() = func;
-> int(*변수이름)(매개변수)

//다른 함수 할당
fcnptr = func2;

//functional Library (C++11 이상)
#include <functional>

std::functional<리턴타입(매개변수)> fcnptr = func;

- 일립시스 (Ellipsis)

//매개변수의 갯수제한을 두지 않고 받는 방법

double findAverage(int count, ...) //count : 매개변수 갯수
{
	double sum = 0;
    va_list list;
    var_start(list, count);
    
    for (int arg = 0; arg < count; ++arg)
    {
    	sum += va_arg(list, int);
    }
    
    var_end(list);
    
    return sum / count;
}

- 연쇄호출(Chaining)

class 내부 함수의 리턴을 class 자신의 reference 값으로 설정하면,
연쇄적으로 호출이 가능하다.

class Calc
{
	int m_value;
    
    Calc& Add(int value) { m_value += value; return *this; }
    Calc& Sub(int value) { m_value -= value; return *this; }
};

int main()
{
	Calc cal(10);
    cal.Add(10).Sub(20).Add(10);
}

- friends keyword

class에서 다른 함수의 선언부를 가져와 friend 선언을 해주면 해당 함수에서는 선언된 class의 private 멤버에 접근할 수 있다.

각자 다른 class에서 공통 함수에 friend를 선언할 경우 전방선언이 필요할 수 있음.

순서에 의해 friend 함수에서 멤버 변수 등을 인식하지 못하면, class에는 선언부만 남겨두고,
인식하지 못한 class의 하단에 구현부를 넣어준다.

- 익명 변수

class A
{
	void print()
    {
    	cout << "A Print" << endl;
    }
};

int main()
{
	A().print();
    A().print(); //위의 객체와 다르기 때문에 생성자와 소멸자가 각각 호출됨.
}

- 연산자 오버로딩

//산술 연산자
class Cents
{
private:
	int m_cents;
public:
	int& getCents() { return m_cents; }
    
	Cents operator + (const Cents &c2) //멤버 함수
    {
    	return Cents(this->m_cents + c2.m_cents);
    }
    
    friend Cents operator + (const Cents &c1, const Cents &c2) //friend 함수
    {
    	return Cents(c1.getCents() + c2.getCents());
    }
};

//입출력 연산자
class Point
{
private:
    double m_x, m_y, m_z;

public:
    Point(double x = 0.0, double y = 0.0, double z = 0.0)
        : m_x(x), m_y(y), m_z(z)
    { }

	//outstream
    friend std::ostream& operator << (std::ostream &out, const Point &point)
    {
        out <<<< point.m_x << ", " << point.m_y << ", " << point.m_z;

        return out;
    }
	
    //instream
    friend std::istream& operator >> (std::istream& in, Point& point)
    {
        in >> point.m_x >> point.m_y >> point.m_z;

        return in;
    }
};

int main()
{
    Point p1(0.0, 0.1, 0.2), p2(3.4, 1.5, 2.0);
    Point p3, p4;

    cout << p1 << " " << p2 << endl;
    cin >> p3 >> p4;
}

//단항 연산자
Cents operator - () const
{
	return Cents(-m_cents);
}

bool operator ! () const
{
	return (m_cents == 0 ? true : false);
}

//비교 연산자

friend bool operator == (const Cents& c1, const Cents& c2)
{
    return c1.m_cents == c2.m_cents;
}

friend bool operator < (const Cents& c1, const Cents& c2)
{
    return c1.m_cents < c2.m_cents;
}

//증감 연산자
Cents& operator ++ () //prefix
{
    ++m_cents;
    return *this;
}

Cents& operator ++ (int) //postfix
{
    Cents temp(m_cents);
    ++(*this);
    return *temp;
}

//첨자 연산자 []
class IntList
{
private:
    int m_list[10];
public:
    int& operator [] (const int index)
    {
        return m_list[index];
    }
    const int& operator [] (const int index) const
    {
        return m_list[index];
    }
};

int main()
{
    IntList list;

    list[3] = 10;
    
    //if
    IntList *list = new IntList;
    
    list[3] = 10; //X
    (*list)[3] = 10; //O
}

//형변환

operator int()
{
	return m_cents;
}

- explicit / delete

class Fraction
{
	int m_numerator;
    int m_denominator;
    
    Fraction(char) = delete; //사용 못하게 막음
    
	(explicit) Fraction(int num = 0, int den = 1)
    	: m_numerator(num), m_denominator(den)
    { }
};
void doSomething(Fraction frac)
{
	cout << frac << endl;
}

int main()
{
	doSomething(7); //원래는 컴파일러에서 Fraction(7)처럼 변환해줌
    				//만약 Fraction 생성자에 explicit 키워드가 앞에 붙는다면 불가능해짐
}

- class 깊은 복사 주의점

//class의 멤버변수로 char *m_data = nullptr;가 정의되어 있을 때,
//이 class를 기본 복사 생성자를 통해 복사하면 새로운 class instance에도 같은 포인터 주소를 가리킨다.
//이 때, 새로운 class instance가 삭제되면, 소멸자에서 해당 포인터 변수가 가리키는 값을 지워버리게 되고,
//원본의 데이터까지 지워버리는 상황이 발생한다. (얕은 복사)
//이 때문에, 깊은 복사를 위해선 별도의 복사 생성자를 정의해줘야 한다.

MyString(const MyString &source) //복사 생성자 (깊은 복사)
{
	m_length = source.m_length;
    
    if (source.m_data != nullptr)
    {
    	m_data = new char[m_length];
        for (int i = 0; i < m_length; ++i)
        	m_data[i] = source.m_data[i];
    }
    else
    	m_data = nullptr;
	}
}

//operator = (대입 연산자) 의 경우에도 비슷하게 정의해줄 수 있음.
MyString& operator = (const MyString &source)
{
	if (this == &source)
    	return *this;
    
    delete[] m_data; //기존에 갖고있던 메모리 할당 해제
    
    m_length = source.m_length;
    
    if (source.m_data != nullptr)
    {
    	m_data = new char[m_length];
        for (int i = 0; i < m_length; ++i)
        	m_data[i] = source.m_data[i];
    }
    else
    	m_data = nullptr;
	}
}

//std::string을 사용하면 필요 없는 일이다.

- Initializer List 생성자

IntArray(unsigned length)
	: m_length(length)
{
	m_data = new int[length];
}

IntArray(const std::initializer_list<int> &list)
	: IntArray(list.size())
{
	int count = 0;
    for (auto & element : list)
    {
    	m_data[count] = element;
        ++count;
    }
}

- 상속 관련 Keyword

//virtual
상속 구조에서 부모 클래스의 메소드에 virtual 키워드를 사용시
자식 클래스의 객체를 부모 클래스의 포인터에 넣어서 호출해도
자식클래스의 메소드가 호출됨.
부모 클래스의 함수를 자식 클래스에서 오버라이딩한 것으로 인식

- 가상 소멸자
부모 클래스 객체에 자식 클래스를 넣을 경우,
자식 클래스의 동적 할당된 메모리를 지우기 위해 소멸자에도 
virtual 키워드를 붙여주면 자식 클래스의 소멸자도 실행됨.

//override
상속 구조에서 자식 클래스의 함수 매개변수 끝에 override 키워드 작성시
오버로딩이 아닌 오버라이드를 의도한것이라고 인식하게 하는 키워드

//final
final 키워드 사용시 자식 클래스에서 더 이상 오버라이딩할 수 없음

- 다이아몬드 상속 문제

A라는 부모클래스를 통해 B와 C클래스를 상속받아 생성할 때,
상속 접근제한자에 virtual을 붙여주지 않으면
B와 C클래스 각각 다른 A클래스를 상속받는 문제가 발생할 수 있음.

class B : virtual public A
와 같이 상속받아야 함.

- Object Slicing

부모 클래스로부터 상속받아 생성된 자식클래스에 새로운 변수가 있는데,
부모 클래스에 자식 클래스 인스턴스를 넣어버린 경우 데이터 슬라이싱 발생

std::vector를 사용하는 경우 
std::vector<std::reference_wrapper<부모 클래스>> vec;
을 사용할 수 있다.

- dynamic cast

Derived d1;
Base *base = &d1;

auto *base_to_d1 = dynamic_cast<Derived1*>(base);
Base로 형변환 됐던 변수를 다시 Derived로 형변환

dynamic_cast의 경우 에러 체크를 통해 에러일 경우 nullptr 반환함. (안전한 형변환)
static_cast는 에러 체크를 하지 않음.

- Template

//함수 템플릿

template<typename T>
T getMax(T x, T y)
{
	return (x > y) ? x : y;
}

//클래스 템플릿

<*.h>
template<typename T>
class MyArray
{
private:
	int m_length;
    T *m_data;
    
public:
	MyArray(int length)
    {
    	m_lenth = length;
        m_data = new T [length];
    }
    
    void print();
}
...

<*.cpp>
template<typename T>
void MyArray<T>::print()
{
	...
}

template void MyArray<char>;
//템플릿 클래스의 멤버함수의 구현부를 cpp 파일로 옮길 경우
explicit instantiation 필요

//