데브웁스

동적 메모리 할당

• 동적 메모리 할당이 필요한 이유
  • 실행 시간에 결정된 크기 만큼의 메모리를 할당하고 싶을때
  • 자동으로 메모리를 해지 하지 말고, 사용자가 원할때 명시적인 해제를 위해
• C 언어
  • malloc으로 할당하고 free로 해지
  • malloc 사용시 주소를 원하는 타입으로 캐스팅 필요
• C++ 언어
  • new로 할당하고 delete로 해지
  • 원하는 타입의 주소를 리턴하므로 캐스팅 불필요
  • new 배열로 할당한 경우 delete[]로 해지(배열을 delete로 해지 시 동작에 대해서는 알수없음 undefined)
  • malloc은 생성하지 호출하지 않지만 new는 생성자를 호출함

int main()
{
    int cnt = 0;

    std::cout << "학생수 ? >>";
    std::cin >> cnt;

    // 학생수 만큼의 메모리 할당이 필요하다.
    int score[cnt]; // g++ ok, vc++ error

    // C Style
    int* p1 = (int*)malloc(sizeof(int) * 10);
    free(p1);

    // C++ Style
    int* p2 = new int; // int 사이즈 할당(4Byte)
    delete p2; // 

    int* p3 = new int[10]; // int 사이즈 배열 할당(4Byte * 10)
    delete[] p3; // new Array 타입으로 생성 시 delete[]로 해지
}

Delete Function(명시적 삭제)

• 특정 타입의 함수를 제공하지 않을 경우 인자 형변환으로 호환 가능한 함수를 호출함
• 특정 타입의 함수를 선언만 하면 해당 함 수 사용시 링크 에러 발생
• 해당 함수를 명시적 삭제(delete)하면 함수 사용시 컴파일 에러 발생

template<typename T>
T Square(T a)
{
    return a * a;
}

void Foo(int a) {}
void Foo(double a) = delete; // double 타입 파라미터 Foo 함수를 명시적 삭제

double Square(double) = delete; // 템플릿에서 double 타입만 제공하지 싶지 않을때

int main()
{
	Foo(3.4); // 명시적 삭제하지 않았을 경우 형변환 되어 Foo(int a) 함수가 실행됨
    Foo(3.4); // 명시적 삭제 상태일때는 컴파일 에러 발생(deleted function error)
    Square(3.4); // 템플릿 함수이지만 double 타입 함수는 삭제됨 에러 발생
}

Suffix Return Type

• C++11 이상
• 리턴 타입을 함수() 뒤에 적는 표기법
• suffix return or trailing return 이라고 함
• 원래의 리턴 값 위치에는 auto를 표기
• 람다 표현식이나 함수 템플릿을 만들때 많이 사용

template<typename T, typename U>
auto Add(T a, U b) -> decltype(a + b) // 리턴타입이 함수 정의부 이후에 결정이 필요할 경우
{
    return a + b;
}

int main()
{
    Add(1, 2.2); // 템플릿 함수를 호출 시 인자 타입이 상이할 경우 템
}

Constexpr Function

• C++11 이상
• 함수 인자로 컴파일 시간에 결정될 수 있는 상수 값이 전달 될 경우 컴파일 시간에 연산을 수행하는 함수
• 함수 인자가 컴파일 시간에 결정되는 상수가 아닌 경우 일반 함수와 동일하게 동작함
• 함수 호출 구문을 배열의 크기나 템플릿 인자등 컴파일 시간 상수가 필요한 곳에서 사용 가능
• 라이브러리 설계에서 많이 사용됨

constexpr int Add(int a, int b)
{
    return a + b;
}

int main()
{
    int n2 = Add(1, 2);
}

Default Parameters

• 함수 호출시 인자 전달을 생략하면 기본값이 적용된다.
• 주의 사항
  • 함수의 마지막 파라미터부터 역순으로만 지정 가능
  • 헤더파일로 분리된 함수의 경우 선언에만 기본값을 정의 한다.(구현부

// 선언부, 구현부 분리 시 선언부에만 기본 파라미터 정의
void func1(int x, int y = 0, int z = 0);

// 구현부 가독성을 위해서 필요시 주석으로 표현
void func1(int x, int y /*= 0 */, int z /*= 0 */)
{
}

int main()
{
    func1(1, 1, 1); // 파라미터 기본값 사용 안함
    func1(1, 1); // 파라미터 기본값 z 사용
    func1(1); // 파라미터 기본값 y, z 사용
}

Function Overloading

• 인자의 개수나 타입이 다르면 동일 이름의 함수를 2개 이상 만들 수 있음
• 사용자 입장에서 일관된 함수를 제공 가능
• 주의사항
  • 디폴트 값이 있는 함수에서는 주의 필요
  • 리턴 타임만 다른 경우는 오버로딩 불가

int square(int a)
{
    return a * a;
}

double square(double a)
{
    return a * a;
}

int main()
{
    square(1); // 정수 파라미터 함수 호출
    square(1.1); // 실수 파라미터 함수 호출
}

Inline Function

• 함수 호출 시 실제 함수로 이동하지 않고 함수의 기계어 코드로 치환함
  • 장점 : 빠름
  • 단점 : 치환되는 함수가 클 경우 목적코드(실행파일)이 커질 수 있음
• 인라인 상태 확인 방법
  • cl : 이름.cpp /FAs /Ob1 -> 이름.asm
  • g++ : 이름.cpp -S -02 -> 이름.s
• 헤더파일에 구현부를 제공하여야 함

int add1(int a, int b)
{
    return a + b;
}

inline int add2(int a, int b)
{
    return a + b;
}

int main()
{
    int a = 1, b = 2;
    int n1 = add1(a, b); // 어샘블리어로 변환 시 함수 호출
    int n2 = add2(a, b); // 어샘블리어로 변환 시 함수자체로 치환
}

Template Function

• 실제 함수가 아닌 함수를 만들어 내는 틀(template)
• 사용자가 템플릿을 호출하는 코드를 보고 컴파일러가 필요한 타입의 함수를 생성
• 템플릿 인자 표기는 "typename" 또는 "class"를 사용
• 함수 뿐 아니라 구조체(or 클래스)도 템플릿으로 만들수 있음
• 잘못 사용시 코드 메모리가 커질 수 있음(Code Bloat 현상)

// 함수를 만들어 내는 틀
template<typename T>
T square(T a)
{
    return a * a;
}

int main()
{
    square<int>(3); // int square(int) 함수 생성
    square<double>(3.3); // double square(double) 함수 생성
    
    square(3); // 생략시 타입 추론으로 int square(int) 함수 생성
    square(3.3); // 생략시 타입 추론으로 double square(double) 함수 생성
}

template<typename T>
struct Point
{
    T x;
    T y;
};


int main()
{
    Point<int> p1; // 멤버가 int인 Point 구조체 생성
    p1.x = 3;

    Point<double> p2; // 멤버가 double인 Point 구조체 생성
    p2.x = 3.3;
}

C++11 for 문

• Java, C#의 foreach()와 유사함
• STL(C++ 표준 라이브러리)의 list, vector 등의 컨테이너 사용가능
• 사용자 정의 list도 사용가능(추가 작업 필요)

#include <iostream>
int main()
{
    int x[5] = { 1,2,3,4,5 };

    // C++11 for
    for ( int n : x )
    {
        std::cout << n << std::endl;
    }

    // C++11 for
    for ( auto n : x ) // 편하게 auto 권장
    {
        std::cout << n << std::endl;
    }

    // C++11 하위 for
    for (int i = 0; i < 10; i++)
    {
        std::cout << n << std::endl;
    }

}

C++17 if init, switch init, if constexpr

• 조건문(if, switch)에 초기화 구문을 포함 가능
• if( 초기화문; 조건문 ), switch( 초기화문; 조건문 )
• if constexpr( 컴파일 시간 조건문 ), 컴파일 시간의 상수 조건만 확인 가능, 템플릿 프로그래밍에서 

#include <iostream>
int main()
{
    // C++17 if
    if ( int result = foo(); result == 1) { }

    // C++17 switch
    switch( int result = foo(); result ) { }

    // C++17 if constexpr
    constexpr int a = 1;
    if constexpr ( a == a) { }

    // 이전 if
    int result = foo();
    if ( result == 1 ) {}

    // 이전 switch
    int result = foo();
    switch( result ) {}
}

C++ 상수를 만드는 방법

• const : 초기값으로 literal뿐 아니라 변수도 사용 가능하다.
• constexpr : 컴파일 시간 상수, 초기값으로 컴파일 시간에 결정된 값만 사용해야 한다. // C++11
• 컴파일 타임 상수는 constexpr을 사용하자.

int main()
{
    int n = 10;

    const int c1 = 10;    // OK(컴파일타임 상수)
    const int c2 = n;    // OK(런타임 상수)

    constexpr int c1 = 10;    // OK(컴파일 타임 상수)
    constexpr int c2 = n;    // Error(런타임 상수는 불가)
}

C++ 문자열(STL string)

• string 타입을 사용하자.(STL의 string 클래스)
• 문자열 처리가 정수형 변수 처럼 직관적으로 사용 할 수 있다.
• C언어의 const char*로의 변환이 필요하면 .c_str()을 사용한다.
• C언어에서는 문자열
• char* 또는 char 배열 사용
• 복사 및 비교를 위해서는 문자열 전용 함수를 사용

#include <iostream>
#include <string.h>
#include <string>

int main()
{
    // C Style
    char s1[] = "hello";
    char s2[10];

    strcpy(s2, s1);
    if(strcmp(s2, s1) == 0)
    {
    }

    // C++ STL
    std::string s1 = "hello";
    std::string s2;
    
    s2 = s1; // C언어 strcpy(s2, s1) 동일
    if (s1 == s2) // C언어 strcmp(s2, s1) == 0 동일
    {
    }
    
    std::string s3 = s1 + s2;
    std::cout << s3 << std::endl;
}

C++ 구조체 바인딩(Structure binding) // C++17

• 구조체 또는 배열의 각 멤버에서 값을 꺼낼때 사용
• 타입은 반드시 auto를 사용해야 한다.

C++ 변수 특징

• 2진수 표기법, 자릿수 표기법(C++11)
• 변수의 중간 선언 가능.
• bool 타입 지원 // C언어(C99)도 가능 했음
• 구조체 만들때 멤버를 초기화 할 수 있음(C++11)

일관된 초기화(Uniform Initialization) // C++11

• 중괄호 초기화(Brace Initialization)라고도 부른다.
• 직접 초기화(Direct Initialization) : 초기화시에 '=' 을 사용하지 않는다.
• 복사 초기화(Copy Initialization) : 초기화시에 '=' 을 사용한다.
• 묵시적 형변환 지원하지 않음

별칭(using)

• typedef : 타입에 대해서 별칭(alias)을 만들때 사용
• using : 타입과 template의 별칭(alias)을 만들때 사용(사용범위가 넓으므로 typedef 보단 using 권장)

#include <iostream>

int main()
{
    int n = 0;
    std::cin >> n;	// 숫자 입력
    std::cout << n;	// 입력 숫자 출력
}

2. 조정자(iomanipulator) 함수

• 헤더 사용 : <iomanip>
• 변환 출력 : std::dec(10진수), std::hex(16진수)
• 문자열 출력 자리수 지정 : std::setw(10자리)
• 문자열 출력 정렬(기본 우측 정렬) : std::left(좌측), std::right(우측)
• 문자열 공백 문자 지정 : std::setfill('*')

#include <ostream>
#include <iomanip>
#include <string>

int main()
{
	int n = 0;
	std::string name = "harry";

	std::cin >> n;	// 숫자 입력
	std::cout << std::hex << n << std::endl; // 입력 숫자 16진수 출력
	std::cout << n << std::endl; // 입력 숫자 출력(16진수로 유지)
	std::cout << std::dec << n << std::endl;// 입력 숫자 10진수로 재변환 출력
	std::cout << name << std::endl;	// "harry" 문자열 출력
	std::cout << std::setw(10) << name << std::endl; // "harry" 문자열 10자리수로 출력(기본 우측 정렬)
	std::cout << std::setw(10) << std::setfill('#') << name << std::endl; // 공백 문자 '#' 채우기
	std::cout << std::setw(10) << std::left << name << std::endl; // "harry" 문자열 10자리수로 출력(좌측 정렬)
	std::cout << std::setw(10) << std::right << name << std::endl; // "harry" 문자열 10자리수로 출력(우측 정렬)
	std::cout << name << std::endl;

}

• namespace 요소에 접근하는 3가지 방법
• qualified name (  완전한 이름 )을 사용한 방법.
• using declaration ( 선언 )을 사용한 방법.
• using directive ( 지시어 )를 사용한 방법.

#include "pch.h"
#include <iostream>

// Harry namespace
namespace Harry
{
    void init() { printf("Harry Init\n"); }
    void destroy() { printf("Harry destroy\n"); }
}

// global namespace
void init()
{
    printf("Global init\n");
}

int main()
{
    std::cout << "Harry World!\n"; 

    // 1. 전체 이름 접근(qualified name)
    Harry::init(); // OK
    Harry::destroy(); // OK

    // 2. using 선언 접근(using declaration)
    using Harry::init;
    init(); // OK
    destroy() // Error

    // 3. using 지시어 접근(using directive)
    using namespace Harry;
    init(); // OK
    destroy(); // OK

    // 4. global namespace(전역 함수 호출)
    ::init(); // OK
}

• C++의 모든 표준 라이브러리는 std namespace 안에 있다.
• C++ 표준 라이브러리를 사용하는 3가지 방법
• qualified name ( 완전한 이름 )을 사용한 방법 -> std::min(1, 2)
• using declaration ( 선언 )을 사용한 방법 -> using std::min;
• using directive ( 지시어 )를 사용한 방법 -> using namespace std;
• using namespace std;를 사용할 경우 이름 충돌에 주의 필요
• 표준 라이브러리를 완전한 이름을 사용하는 것이 좋다.
• 표준 라이브러리 헤더 파일 모양
• C : 파일 이름 뒤에 .h 를 붙인다. -> <stdio.h>
• C++ : 파일 이름 뒤에 .h 가 붙지 않는다. -> <cstdio>
• 사용자가 헤더를 만들때는 .h 를 붙이는 것이 관례이다. -> "myheader.h"
• C++에서 C언어 헤더 사용하는 방법
• 기존의 C언어 헤더 파일을 모두 계속 사용할 수 있다.
• C언어 헤더에서 '.h'를 제거하고 앞에 'c'를 붙여서 사용한다.
• <string.h> -> <cstring>
• <stdlib.h> -> <cstdlib>
• <math.h> -> <cmatch>