🧞‍♂️ 신입 개발자 기술면접 : C++ 02

안녕하세요, 쫀냐미입니다.
주언어가 C++이지만 Java, Python 언어 관련 지식도 첨부한 점 참고 부탁드립니다. 
틀린 내용이 있다면 댓글로 알려주시면 감사하겠습니다.

 

🗣️ 함수 포인터가 무엇인가요? 몇 바이트인지도 말씀해 주세요.

 

함수 포인터는 특정 함수를 가리키는 데 사용되는 포인터입니다. 상황에 따라 다른 함수를 실행해야 할 때, 매번 조건을 확인하여 해당 함수를 호출하는 것은 비효율적일 수 있습니다. 이때 함수 포인터를 활용하면, 처음에 한 번만 조건을 체크하여 적절한 함수를 함수 포인터로 지정합니다. 그 후에는 조건을 다시 검사할 필요 없이 해당 함수 포인터를 호출함으로써, 코드를 보다 간결하고 효율적으로 작성할 수 있습니다. 이 방법은 프로그램의 가독성을 높이고, 유지 보수를 용이하게 하는 데 도움이 됩니다.

 

함수 포인터의 크기는 시스템 아키텍처에 따라 다릅니다. 32비트 시스템에서는 4바이트, 64비트 시스템에서는 8바이트를 차지합니다. 이는 일반적인 포인터의 크기와 같습니다.

 

아래 코드에는 condition 변수의 값에 따라 functionA 또는 functionB 중 하나가 functionPointer에 할당됩니다. 이렇게 하면 매번 조건을 체크할 필요 없이, functionPointer()를 호출하기만 하면 됩니다.

#include <iostream>

void functionA() {
    std::cout << "Function A is called." << std::endl;
}
void functionB() {
    std::cout << "Function B is called." << std::endl;
}

int main() {
    void (*functionPointer)();  // 함수 포인터 선언
    bool condition = true;      // 조건 변수

    // 조건에 따라 함수 포인터를 다른 함수에 할당
    if (condition) {
        functionPointer = functionA;
    } else {
        functionPointer = functionB;
    }

    // 함수 포인터를 통해 함수 호출
    functionPointer();

    return 0;
}

---

🗣️ 맵과 해시 맵에 대해서 설명하고, 어떤 경우에 어떤 맵을 쓰는 게 좋은지 이야기해보세요

 

C++에서 Map과 Hash Map은 (Key, Value)으로 이뤄진 pair객체를 저장하는 연관 컨테이너입니다.

이 두 컨테이너는 사용 목적과 내부 구현 방식에서 차이가 있습니다.

1. map

`std::map`은 균형 이진 트리 (보통 레드-블랙 트리)를 기반으로 구현됩니다.
각 요소는 키에 의해 자동으로 오름차순 정렬되며, 중복 키를 허용하지 않습니다.
탐색, 삽입, 삭제 작업은 일반적으로 `O(log n)` 시간 복잡도를 가집니다.
알아서 정렬된 상태를 유지해야 한다면 특히 유용합니다.

std::map<std::string, int> map;
map["apple"] = 5;
map["banana"] = 8;

 

2. unordered_map
`std::unordered_map`은 해시 테이블을 기반으로 구현됩니다.
각 요소는 해시 함수에 의해 버킷에 저장되며, 키의 순서를 보장하지 않습니다.

이 요소들은 해시 함수의 결과에 따라 저장되므로 순서가 불규칙합니다.
또한 map과 마찬가지로 중복 키를 허용하지 않습니다.

• 중복 키를 허용하는 해시 기반 컨테이너가 필요하다면, std::unordered_multimap을 사용할 수 있습니다. std::unordered_multimap은 동일한 키에 여러 값을 저장할 수 있습니다.

평균적인 경우 삽입, 삭제, 탐색 작업이 `O(1)` 시간 복잡도를 가지나, 최악의 경우 `O(n)`이 될 수 있습니다.
`std::unordered_map`은 빠른 접근 속도가 필요할 때, 특히 요소의 순서가 중요하지 않을 때 유용합니다.

std::unordered_map<std::string, int> hashMap;
hashMap["apple"] = 5;
hashMap["banana"] = 8;

 

`std::map`
키-값 쌍이 특정 순서(예: 사전순, 오름차순, 내림차순)로 정렬되어야 할 때.
중간 중간에 요소의 삽입과 삭제가 빈번하게 일어나고, 이 때 정렬 상태를 유지해야 할 때.

(데이터의 변동이 자주 발생하는 경우에는 unordered_map이 일반적으로 더 빠른 성능을 보일 수 있습니다. 하지만 데이터가 정렬된 상태를 유지해야 하는 경우에는 map이 더 적합할 수 있습니다. `unordered_map`은 일반적으로 더 빠른 성능을 제공하지만, 특정 상황에서는 `std::map`의 정렬 기능이 더 유리할 수 있습니다. )

`std::unordered_map`
삽입, 삭제, 탐색 작업의 속도가 중요한 경우, 특히 대량의 데이터를 다룰 때.
요소의 순서가 중요하지 않거나, 키-값 쌍의 정렬이 불필요한 경우.

---

🗣️ call by value, call by reference 차이가 무엇인가요?

 

value의 경우 데이터 값을 복사해서 함수로 전달하기 때문에 원본 데이터가 변경될 가능성이 없습니다. 또한 인자를 넘겨줄 때 마다 메모리 공간을 할당하기 때문에 메모리 공간을 좀 더 사용해야합니다.

reference의 경우는 메모리 공간 할당의 문제를 벗어납니다. 참조한 데이터를 변경시 원본 데이터 값이 변경되기 때문에 신경써서 사용해야 합니다.

---

🗣️ 스마트 포인터에 대해서 설명해주세요.

 

C++에서 메모리 누수(memory leak)로부터 프로그램의 안전성을 보장하기 위해 스마트 포인터를 제공하고 있습니다. 포인터처럼 동작하는 클래스 템플릿으로 사용이 끝난 메모리를 자동으로 해제해줍니다.

 

`unique_ptr`

하나의 스마트 포인터만이 특정 객체를 소유할 수 있도록 객체에 소유권 개념을 도입한 포인터입니다. 이 스마트 포인터는 해당 객체의 소유권을 가지고 있을 때만, 소멸자가 해당하는 객체를 삭제할 수 있습니다.

 

`shared_ptr`

참조하는 스마트 포인터가 총 몇 개인지 참조하는 스마트 포인터입니다. 이렇게 참조하고 있는 스마트 포인터의 개수를 참조 횟수라고 합니다. 참조 횟수는 특정 객체에 새로운 `shared_ptr`이 추가될 때 마다 `1`씩 증가하고 수명이 다할 때 `1`씩 감소합니다. 참조 횟수가 `0`이 되면 자동으로 `delete` 키워드가 불러 메모리를 해제합니다.

 

`weak_ptr` 

하나 이상의 `shared_ptr`인스턴스가 소유하는 객체에 대한 접근을 제공하지만, 소유자의 수에는 포함되지 않는 스마트 포인터입니다.  만약 서로가 상대방을 가리키는 `shared_ptr`를 가지고 있다면, 참조 횟수는 절대 `0`이 되지 않으므로 메모리는 영원히 해제되지 않습니다. 이렇게 서로가 상대방을 참조하고 있는 상황을 순환 참조라고 합니다. `weak_ptr`은 바로 `shared_ptr`인스턴스 사이의 순환 참조를 제거하기 위해 사용됩니다.

---

🗣️ 람다란?

 

쉽게 말해 이름이 없는 함수입니다. 캡쳐, 인자, 반환형, 몸통으로 구성되어 있으며 런타임 시 이름은 없지만, 메모리 상에 임시적으로 존재하는 클로져 객체가 생성됩니다.

 

캡쳐 하는 방법 (캡쳐의 범위는 전역)

• `[a,&b]` a를 복사로 캡처, b를 참조로 캡처.
• `[this]` 현재 객체를 참조로 캡처.
• `[&]` 몸통에서 쓰이는 모든 변수나 상수를 참조로 캡처하고 현재 객체를 참조로 캡처.
• `[=]` 몸통에서 쓰이는 모든 변수나 상수를 복사로 캡처하고 현재 객체를 참조로 캡처.
• `[]` 아무것도 캡처하지 않음.

---

🗣️ 전위 연산과 후위 연산의 차이가 무엇인가요?

 

전위연산과 후위연산과의 차이는 임시객체를 만들어서 리턴하는가? 의 차이 입니다.

Debug 모드의 경우에는 후위연산자의 경우에는 임시객체를 만들어 리턴하여 당연히 전위연산보다 느리지만,

Release 모드에서는 컴파일러의 최적화로 둘의 성능은 같다고 합니다.

---

🗣️ 절차지향, 객체지향의 차이가 무엇인가요?

 

절차지향 프로그래밍은 Top-Down 방식으로 접근하며 순차적인 처리가 중요시 되어 프로그램이 전체적으로 연결되도록 만드는 프로그래밍 기법입니다. 대표적인 절차지향 언어는 C언어가 있습니다. 함수로부터 데이터를 받아서 기능을 구현하는 방식으로 진행됩니다. 절차적 프로그래밍 이라는 말이 더 정확합니다. 코드의 가독성이 좋고, 실행속도가 빠르다는 장점이 있지만, 유지보수 및 디버깅이 어렵습니다.

 

객체지향 프로그래밍은 Bottom-Up 방식으로 접근하며, 데이터와 절차를 하나의 Object로 묶어서 처리합니다. 모듈화 및 캡슐화로 유지보수에 용이하며, 코드의 재사용성이 높습니다. 처리속도가 상대적으로 느리고, 많은 양의 메모리를 사용한다는 단점이 있습니다. 

---

🗣️ 함수 객체 (Function Object, Functor) 가 무엇인가요?

 

함수 호출 연산자 `operator()` 를 오버로딩하여 함수처럼 동작하는 객체를 구현한 것입니다. 함수와 달리 객체를 사용하면 속성을 지닐 수 있는 것이 가능하고, 함수 객체가 일반적인 함수보다 빠르기도 하고 각각의 함수 객체는 서로 다른 타입을 지닌다는 장점을 지닙니다.

#include <iostream>
// 함수 객체를 정의하는 클래스
class Adder {
public:
    // 생성자
    Adder(int n) : num(n) {}
    // 함수 호출 연산자 오버로딩
    int operator()(int i) const {
        return num + i;
    }
private:
    int num;
};
int main() {
    Adder add_five(5); // 5를 더하는 함수 객체 생성
    std::cout << add_five(3) << std::endl; // 8 출력 (5 + 3)
    return 0;
}

---

🗣️ volatile 키워드가 무엇인가요?

 

`volatile` 키워드로 선언된 변수는 외부적인 요인으로 그 값이 언제든지 바뀔 수 있음을 뜻합니다.

---

🗣️ 값에 의한 전달보다, 참조에 의한 전달이 더 나은 이유는 무엇인가?

 

객체가 값으로 전달되면 객체의 새로운 사본이 생성되어 함수에 전달됩니다. 이 전달 방식은 굉장히 큰 벡터 객체를 전달하는 경우 사본을 생성하는 데 비용이 많이 듭니다. 그래서 클래스가 복사 생성자를 `private`으로 선언하는 등의 방법을 통해, 클라이언트가 복사본을 생성하지 못하게 하는 경우도 있습니다. 

 

참조로 전달하면 객체 자체가 전달됩니다. 정확히 말하면 함수는 객체의 주소를 받습니다. 이 경우 함수는 목적에 따라서 객체를 수정할 수 있습니다. 함수가 객체를 수정하지 못하게 하려면, `const` 참조로 객체를 전달해야 합니다.

 

값으로 전달할 때 발생 가능한 또 다른 문제는 원하지 않는 암시적 변환이 일어날 수 있다는 점입니다. 예를 들면 파생 클래스가 다형성을 방지하는 기본 클래스로 캐스팅될 수 있습니다. 

---

🗣️ 이터레이터란? 이터레이터와 포인터의 유사점과 차이점?

 

둘 다 값을 얻기 위해 역참조할 수 있다는 점에서 비슷합니다. 이터레이터는 컨테이너에 저장되어 있는 원소들을 참조할 때 사용합니다. STL 컨테이너에 저장된 요소를 반복적으로 순회하여, 각각의 요소에 대한 접근을 제공하는 객체입니다. 즉, 컨테이너의 구조나 요소의 타입과는 상관없이 컨테이너에 저장된 데이터를 순회하는 과정을 일반화한 표현입니다. 템플릿이 타입과 상관없이 알고리즘을 표현할 수 있게 해준다면, 이터레이터는 컨테이너와 상관없이 알고리즘을 표현할 수 있게 해주는 것입니다.

 

이터레이터는 포인터를 일반화한 것으로, 포인터는 반복자가 가져야할 모든 요구 사항을 만족합니다.

반복자가 가져야 할 모든 요구 사항과 정의되어야 할 연산자는 다음과 같습니다.

• 가리키는 요소의 값에 접근할 수 있어야 한다. 따라서 참조 연산자가 정의되어야 한다.
• 반복자 사이의 대입 연산, 비교 연산이 가능해야 한다. 따라서 대입, 관계 연산자가 정의되어야 한다. 
• 가리키는 요소의 주변 요소로 이동할 수 있어야 한다. 따라서 증가 연산자(++)가 정의되어야 한다.

출처 https://song-ift.tistory.com/63

 

반복자는 포인터와 다르게, 컨테이너의 객체를 참조하므로 반복자에 대한 삭제 개념이 없습니다. (컨테이너는 RAII 패턴을 따르며 메모리 관리를 담당합니다.)

---

🗣️ 생성자란? 기본 생성자, 복사 생성자, 이동 생성자는 어떻게 다른가?

 

객체 지향 프로그래밍에서 생성자는 객체를 만드는 데 사용되는 특수한 타입의 서브 루틴 (같은 프로세스 내에서 Context Switching 없이 재사용 가능한 코드 블록으로, OS의 직접적인 관리 없이 실행된다) 입니다. 생성자는 사용할 새 객체를 준비합니다. 일반적으로 생성자는 필드를 설정하기 위한 인수를 받구요, 필드 자체는 객체가 될 수 있으므로 생성자가 다른 생성자를 호출할 수 있습니다.

 

기본 생성자는 매개변수가 없거나 모든 매개변수에 기본값이 있는 생성자입니다. 클래스의 객체가 명시적인 초기값 없이 생성될 때 호출됩니다. 예를 들어, `MyClass obj;`와 같이 객체를 생성할 때 기본 생성자가 호출됩니다.

 

복사 생성자는 클래스 인스턴스에 대한 왼값 참조를 인수로 사용하여 호출할 수 있습니다. 보통 `ClassName(const ClassName&)` 형태로 구현한다. 인스턴스의 새 복사본이 `ClassName new_instance(existing_instance)`와 같이 명시적으로 초기화되거나 컴파일러에 의해 암시적으로 초기화될 때 호출된다. 예를 들면, 인스턴스가 값으로 함수에 전달되거나 값으로 반환될 때다.

이동 생성자는 클래스 인스턴스에 대한 오른값 참조를 인수로 사용하여 호출할 수 있는 생성자입니다. C++11부터 도입된 개념으로, 임시 객체와 같이 복사할 필요 없이 '이동'할 수 있는 객체를 초기화할 때 사용됩니다. 이동 생성자는 리소스를 '복사'하는 것이 아니라 '이동'함으로써 성능을 향상시킵니다. 이동 생성자의 형태는 `MyClass(MyClass&&)` 와 같으며, rvalue 참조를 사용합니다. 일반적으로 초기화 후에 소멸되는 임시 객체에서 새 인스턴스가 초기화될 때 호출된다.

class Knight
{
public:
	Knight() {cout << "기본 생성자" << endl;}
	Knight(const Knight&) {cout << "복사 생성자" << endl;}
	Knight(Knight&&) noexcept {cout << "이동 생성자" << endl;}
};

 

---

🗣️ 이미 명시적인 생성자가 작성되어있으면 기본 생성자는 호출되나요?

 

C++에서 클래스에 명시적인 생성자를 작성하면, 컴파일러는 기본 생성자를 자동으로 생성하지 않습니다. 즉, 클래스에 하나 이상의 명시적 생성자가 있고, 그 중 어느 것도 기본 생성자(매개변수가 없는 생성자) 의 역할을 수행하지 않는 경우, 기본 생성자는 제공되지 않습니다.

이러한 상황에서 클래스의 객체를 기본 생성자를 사용하여 생성하려고 하면, 컴파일 오류가 발생합니다. 예를 들어, 클래스 `MyClass`에 매개변수를 가진 생성자만 정의되어 있다면, `MyClass obj;` 와 같은 코드는 컴파일 에러를 일으킬 것입니다.

만약 클래스에 명시적인 생성자가 있지만 여전히 기본 생성자가 필요한 경우, 개발자는 직접 기본 생성자를 명시적으로 작성해야 합니다. 

class MyClass {
public:
    MyClass() { // 기본 생성자 명시적 정의
        // 초기화 코드
    }

    MyClass(int value) { // 다른 생성자
        // 초기화 코드
    }
};

이렇게 하면 `MyClass`의 객체를 기본 생성자 또는 다른 생성자를 사용하여 생성할 수 있습니다.

---

🗣️ 얕은 복사 문제점, 깊은 복사 필요성이 뭔가요?

 

얕은 복사(Shallow Copy)와 깊은 복사(Deep Copy)는 객체를 복사할 때 데이터를 다루는 방식의 차이에서 발생하는 중요한 개념입니다. C++에서 이들의 차이와 각각의 문제점 및 필요성을 이해하는 것은 매우 중요합니다.

얕은 복사는 객체의 각 멤버를 다른 객체로 복사하는 과정에서 멤버 데이터의 비트-바이트 값을 그대로 복사합니다. 이 방식은 기본 데이터 타입(int, char 등)을 복사할 때 문제가 없습니다. 하지만, 포인터나 동적 할당된 메모리를 가진 클래스 객체를 얕은 복사할 경우 문제가 발생할 수 있습니다. 얕은 복사로 인해 두 객체의 포인터가 같은 메모리 주소를 가리키게 되면, 한 객체에서 메모리를 수정하거나 해제하면 다른 객체에도 영향을 미칩니다.

• 두 객체가 같은 메모리를 가리킬 때, 한 객체가 소멸하면서 메모리를 해제하고 나면, 다른 객체도 같은 메모리를 해제하려고 할 때 이미 해제된 메모리에 접근하게 되어 오류가 발생합니다.
• 한 객체가 메모리를 해제한 후, 다른 객체가 해당 메모리에 접근할 수 없게 되면, 그 메모리는 더 이상 사용할 수 없게 되면서 메모리 누수가 발생할 수 있습니다.

 

깊은 복사는 객체의 모든 멤버를 복사할 때, 포인터나 참조된 데이터까지도 새로운 복사본을 생성하여 복사합니다. 즉, 원본 객체와 복사된 객체가 서로 독립적인 메모리를 가지게 됩니다. 깊은 복사를 사용하면, 각 객체가 자신만의 데이터 사본을 가지게 되므로 한 객체의 변경이 다른 객체에 영향을 미치지 않습니다.각 객체가 독립적인 메모리를 관리하기 때문에, 메모리 누수나 이중 해제와 같은 문제를 예방할 수 있습니다.

따라서, 포인터나 동적 할당된 메모리를 다루는 클래스의 경우, 복사 생성자와 할당 연산자를 오버로딩하여 깊은 복사를 구현하는 것이 중요합니다. 이렇게 함으로써 객체 간의 독립성을 유지하고 메모리 관련 문제를 방지할 수 있습니다.

---

🗣️ C 스타일 문자열과 C++ 문자열의 차이점은 무엇인가요?

 

C 스타일 문자열은 문자의 배열로 표현되며, 문자열의 끝은 null 문자 `\0`로 표시됩니다. 
- 문자 배열을 사용합니다 `char str[]`
- 문자열의 끝은 null 문자(`\0`)로 구분됩니다.
- 문자열 처리를 위해 표준 라이브러리 함수(예: `strcpy`, `strlen` 등)를 사용합니다.
- 메모리 관리는 수동으로 해야 합니다 (동적 할당 및 해제).
- 버퍼 오버플로우와 같은 보안 문제에 취약할 수 있습니다.

C++ 스타일 문자열은 `std::string` 클래스를 사용하여 문자열을 표현합니다. 이는 C++ 표준 라이브러리의 일부입니다.
- `std::string` 클래스를 사용합니다.
- 문자열 처리를 위한 다양한 멤버 함수와 연산자 오버로딩을 제공합니다 (예: `append`, `length`, 연산자 `+` 등).
- 메모리 관리는 자동으로 이루어집니다 (동적으로 크기 조정).
- 보안과 관련하여 더 안전합니다 (버퍼 오버플로우 위험 감소).
- 문자열을 객체로 처리하여 더 복잡한 작업을 쉽게 수행할 수 있습니다.

유사점
- 둘 다 문자 데이터를 저장하고 처리하는 기본적인 목적을 가집니다.
- C++에서는 C 스타일 문자열을 `std::string`으로 쉽게 변환할 수 있으며 (`std::string str = "C-style string";`), 반대로도 가능합니다 (`const char* cstr = str.c_str();`).
- 둘 다 ASCII 문자를 저장하고 처리하는 데 사용할 수 있습니다.

즉 C 스타일 문자열과 C++ 스타일 문자열은 기본적으로 같은 데이터(문자)를 다루지만, C 스타일은 더 낮은 수준의 메모리 관리와 직접적인 데이터 접근을 허용하며, C++ 스타일은 더 높은 수준의 추상화와 안전한 메모리 관리를 제공합니다.

---

🗣️ v.push_back("xyzzyx") 와 v.emplace_back("xyzzyx")의 차이점은? 어느 쪽을 사용하는 것이 더 좋은가요?

 

`std::vector`의 `push_back`과 `emplace_back` 함수는 벡터의 끝에 새로운 요소를 추가하는 데 사용되지만, 작동 방식과 성능 면에서 차이가 있습니다.

`push_back` 은 전달받은 객체를 임의 복사하거나 이동시켜서 값을 복사합니다. 즉, 따로 추가적인 연산이 필요합니다.
`emplace_back` 은 필요한 인자를 직접 parameter로 받아 vector 내부에서 직접 객체를 생성-삽입-소멸 하며 추가하므로 복사와 임시 객체 생성을 피할 수 있습니다. 
결론적으로, `push_back`으로 하여도 컴파일러 내부적으로 최적화하므로 `emplace_back`으로 하는 것과 별 차이가 없을 수 있습니다. 그러나 모든 상황에서 `emplace_back`이 유리하다고 할 순 없고, `push_back`이 효율적일 수도 있습니다.

출처: https://song-ift.tistory.com/63

`push_back` 함수는 기존 요소의 복사본을 벡터의 끝에 추가합니다. 문자열 `"xyzzyx"`와 같은 경우, `push_back`은 문자열의 복사본을 생성하여 벡터에 추가합니다.

std::vector<std::string> v;
v.push_back("xyzzyx");

이 예에서, 문자열 리터럴 `"xyzzyx"`는 `std::string` 객체로 변환되고, 이 객체는 `push_back`을 통해 벡터에 복사됩니다.

`emplace_back` 함수는 객체를 벡터의 현재 위치에 직접 구성(생성)합니다. 이는 복사나 이동이 필요 없으므로 성능상 이점을 제공할 수 있습니다.

std::vector<std::string> v;
v.emplace_back("xyzzyx");

이 예에서, `emplace_back`은 문자열 리터럴 `"xyzzyx"`를 사용하여 벡터 내부에서 직접 `std::string` 객체를 구성합니다.

어느 것을 사용하는 것이 더 좋은가요?
- 성능 측면: `emplace_back`은 원본 요소를 직접 구성하기 때문에, 특히 복사 비용이 큰 객체를 다룰 때 성능상의 이점을 제공합니다. `push_back`은 객체를 복사하거나 이동해야 하므로 추가 비용이 발생할 수 있습니다.
- 일반적인 사용: 단순한 타입(예: 기본 데이터 타입, 작은 크기의 사용자 정의 타입)의 경우 `push_back`과 `emplace_back` 사이의 성능 차이는 미미할 수 있습니다. 하지만 복잡한 객체나 대용량 데이터를 다룰 때는 `emplace_back`이 더 효율적일 수 있습니다.

즉 `emplace_back`은 복사나 이동 없이 직접 객체를 생성하기 때문에 성능상으로 보통 더 좋은 선택입니다. 그러나 성능 차이가 크게 중요하지 않은 경우나 코드의 가독성을 중시하는 경우에는 `push_back`을 사용하는 것도 적절할 수 있습니다. 객체의 생성자가 복잡하거나 특별한 방식으로 객체를 초기화해야 하는 경우에는 `emplace_back`이 더 유리합니다

---

🗣️ vector 를 사용할 때 왜 처음부터 reserve() 로 메모리를 잡아주나요?

 

capacity가 변화할 때마다 기존에 있던 데이터를 복사하고 이런 부분에서 비용이 들어가니, 처음부터 `reserve()` 로 원하는 capacity 를 잡아주게 되면 복사하는 부분이 생략되서 더 효율적이기 때문입니다.

 

🗣️ 더 자세히 설명해줄래요?

 

`std::vector`는 동적 배열을 구현하는 C++ 표준 라이브러리 클래스로 자동으로 크기를 조정할 수 있지만, 이 기능은 내부적으로 비용이 발생하는 작업을 수반합니다.

`std::vector`에 요소를 추가할 때, 현재 할당된 메모리(용량, capacity)가 충분하지 않으면, `vector`는 새로운, 더 큰 메모리 블록을 할당하고 기존 데이터를 새로운 위치로 복사합니다. 이 과정은 다음 단계를 포함합니다:
1. 새로운 메모리 할당: 현재 용량보다 큰 새로운 메모리 블록을 할당합니다.
2. 데이터 복사: 기존 요소들을 새로 할당된 메모리로 복사합니다.
3. 기존 메모리 해제: 기존 메모리 블록을 해제합니다.

이 과정은 `push_back`이나 `emplace_back`을 호출할 때마다 벡터의 용량이 부족할 때 발생합니다. 이로 인해, 특히 크기가 큰 객체들을 다룰 때 상당한 성능 저하가 발생할 수 있습니다.`reserve` 메서드를 사용하면 `std::vector`의 초기 용량을 사전에 설정할 수 있습니다. 이렇게 하면 초기에 충분한 메모리를 할당함으로써, 요소 추가 시 반복적인 메모리 재할당과 데이터 복사 과정을 피할 수 있습니다.

예를 들어, 벡터에 1000개의 요소를 추가할 계획이라면, `reserve(1000)`을 호출하여 처음부터 1000개의 요소를 저장할 수 있는 충분한 메모리를 확보할 수 있습니다. 이는 특히 다음과 같은 상황에서 유용합니다.
1. 크기가 큰 객체들을 다룰 때 메모리 재할당과 복사로 인한 오버헤드를 줄일 수 있습니다.
2. 데이터를 빠르게 삽입하고, 메모리 재할당으로 인한 성능 저하를 피해야 하는 경우.
3. 불필요한 메모리 할당과 해제를 줄여 메모리 사용을 최적화할 수 있습니다.
따라서, `reserve` 메서드를 사용하는 것은 메모리 재할당과 데이터 복사에 따른 비용을 줄임으로써 특히 대량의 데이터를 다루거나, 성능이 중요한 애플리케이션에서 중요한 최적화 방법입니다. 

---

🗣️ vector, list 차이점이 뭔가요?

 

`std::vector`와 `std::list`는 C++ 표준 라이브러리에서 제공하는 두 가지 중요한 컨테이너 타입으로, 각각의 특성과 사용 사례가 다릅니다.

`std::vector`는 동적 배열을 구현하는 컨테이너입니다. 이의 주요 특징은 다음과 같습니다:

`vector`는 메모리에 연속적으로 요소를 저장합니다. 이로 인해 인덱스를 이용한 빠른 접근이 가능합니다.
인덱스를 이용해 `O(1)` 시간 안에 어떤 요소에도 접근할 수 있습니다.
요소를 추가할 때 현재 할당된 메모리가 부족하면 새로운, 더 큰 메모리 블록을 할당하고 기존 데이터를 복사해야 합니다.
중간에 요소를 삽입하거나 삭제하는 경우 비용이 높습니다. 모든 뒤쪽 요소들을 이동해야 하기 때문입니다.

`std::list`는 이중 연결 리스트를 구현하는 컨테이너입니다. 이의 주요 특징은 다음과 같습니다:
각 요소는 메모리의 다른 위치에 할당되고 포인터를 통해 서로 연결됩니다.
무작위 접근이 불가능하며, 특정 요소에 접근하려면 시작점부터 순차적으로 이동해야 합니다.
중간에 요소를 삽입하거나 삭제하는 것이 효율적입니다. 포인터만 변경하면 되기 때문에 상대적으로 빠릅니다.
각 요소가 두 개의 추가 포인터(이전 및 다음 요소를 가리키는)를 유지해야 하므로 추가 메모리를 사용합니다.

- **`std::vector`**: 무작위 접근이 자주 필요하거나 요소의 삽입 및 삭제가 주로 끝부분에서 이루어지는 경우에 적합합니다. 예를 들어, 배열과 유사한 데이터 구조가 필요한 경우에 사용됩니다.
- **`std::list`**: 중간 삽입 및 삭제 작업이 자주 발생하고, 순차적 접근이 주로 이루어지는 경우에 적합합니다. 예를 들어, 요소의 순서 변경이 빈번한 경우에 유리합니다.

---

🗣️ list 는 왜 이중 연결 리스트로 구현되었을거라 생각하나요?

 

`std::list`가 이중 연결 리스트(double-linked list)로 구현되어 있는 이유는 몇 가지 주요한 장점 때문입니다. 이중 연결 리스트는 각 노드가 두 개의 포인터를 갖고 있어서, 하나는 이전 노드를 가리키고 다른 하나는 다음 노드를 가리킵니다. 이러한 구조는 다음과 같은 이점을 제공합니다

이중 연결 리스트는 양방향으로 순회할 수 있습니다. 즉, 리스트의 시작부터 끝까지, 또는 그 반대로도 이동할 수 있습니다. 이는 특정 상황에서 데이터 처리를 더 유연하게 만들어 줍니다.
이중 연결 리스트에서 노드의 삽입이나 삭제는 매우 효율적입니다. 특정 노드를 삭제하거나 삽입할 때, 이전과 다음 노드의 포인터만 수정하면 되기 때문에 상대적으로 적은 연산으로 작업을 완료할 수 있습니다. 이는 특히 리스트의 중간에 요소를 추가하거나 삭제할 때 유용합니다.
어떤 경우에는 리스트의 끝에서 시작으로, 또는 그 반대로 이동해야 하는 상황이 발생합니다. 이중 연결 리스트는 이러한 양방향 이동을 쉽게 할 수 있게 해줍니다. 각 노드는 독립적으로 메모리에 할당되므로, 전체 리스트를 재할당할 필요 없이 개별 노드를 추가하거나 제거할 수 있습니다. 이는 메모리 사용량을 최적화하고, 큰 데이터 세트를 다룰 때 메모리 할당의 오버헤드를 줄일 수 있습니다.

단점으로는, 이중 연결 리스트는 각 노드마다 추가적인 메모리(이전 및 다음 노드를 가리키는 포인터)가 필요하므로, 메모리 사용량이 증가합니다. 또한, 무작위 접근(random access)이 비효율적이기 때문에, 특정 인덱스의 요소에 접근하기 위해서는 처음부터 순차적으로 노드를 탐색해야 합니다. 이러한 특성 때문에 `std::list`는 중간 삽입 및 삭제가 빈번하고, 양방향 순회가 필요한 경우에 적합한 자료구조입니다.

---

🗣️ map, set, multimap 차이점이 뭔가요?

 

`std::map`, `std::set`, `std::multimap`은 C++ 표준 라이브러리의 연관 컨테이너(associative container)로, 각각 특정한 방식으로 데이터를 저장하고 관리합니다. 이들의 주요 차이점을 간결하게 설명하겠습니다.

- `std::map`은 키와 값의 쌍을 저장합니다. 각 키는 고유해야 합니다.
- 키에 따라 자동으로 정렬됩니다. 기본적으로 키의 오름차순으로 정렬됩니다.
- 이진 검색 트리(대개 레드-블랙 트리)를 사용하여 구현되므로 검색, 삽입, 삭제 작업이 로그 시간 복잡도를 가집니다.
- 데이터베이스의 키-값 쌍과 유사한 구조를 메모리 내에서 표현할 때 자주 사용됩니다.

- `std::set`은 고유한 요소만 (오직 키만을) 저장합니다. 즉, 중복된 요소는 허용되지 않습니다.
- 요소는 자동으로 정렬됩니다. 기본적으로 오름차순으로 정렬됩니다.
- `std::map`과 유사하게 이진 검색 트리를 사용하여 구현되므로, 로그 시간 복잡도를 가집니다.
- 고유한 요소의 집합을 관리할 때 사용됩니다. 예를 들어, 중복을 허용하지 않는 목록을 관리할 때 적합합니다.

- `std::multimap`은 `std::map`과 유사하지만, 하나의 키에 여러 값을 연결할 수 있습니다. 즉, 중복 키를 허용합니다.
 키에 따라 자동으로 정렬됩니다. `std::map`과 동일한 방식으로 정렬됩니다.
- `std::map`과 동일하게 이진 검색 트리 기반으로 구현되어 있습니다.
- 하나의 키에 여러 값을 연결해야 할 때 사용됩니다. 예를 들어, 키가 카테고리이고 값이 여러 아이템일 수 있는 경우에 적합합니다.

추가 비교
- 모두 이진 검색 트리를 사용해 요소를 정렬합니다. 이로 인해 검색, 삽입, 삭제 작업이 효율적입니다.
- `std::set`은 중복을 허용하지 않지만, `std::multimap`은 키에 대한 중복을 허용합니다. `std::map`은 키의 중복을 허용하지 않습니다.

이 컨테이너들은 각각의 특정 사용 사례에 따라 선택됩니다. `std::map`과 `std::set`은 일반적으로 데이터 구조와 알고리즘에서 가장 자주 사용되며, `std::multimap`은 특정한 경우에 필요할 때 사용됩니다. 

---

🗣️ shared_from_this() 와 shared_ptr(this) 는 같나요?

 

`shared_from_this()`와 `shared_ptr(this)`는 비슷해 보일 수 있지만, 실제로는 매우 다른 목적과 사용법을 가지고 있습니다. 

- `shared_from_this()`는 객체의 수명 관리가 이미 `std::shared_ptr`에 의해 이루어지고 있을 때 안전하게 해당 객체에 대한 추가적인 `shared_ptr`를 생성할 수 있는 방법을 제공합니다.
- 이 메서드는 해당 객체에 대한 새로운 `std::shared_ptr` 인스턴스를 제공합니다. 이 인스턴스는 원래 객체에 대한 참조 카운트를 증가시킵니다.
- 객체가 `std::shared_ptr`에 의해 관리되지 않을 때 `shared_from_this()`를 호출하면, `std::bad_weak_ptr` 예외가 발생합니다.

- 클래스의 내부에서 `shared_ptr(this)`를 사용하는 것은 해당 클래스의 `this` 포인터로 새로운 `std::shared_ptr` 인스턴스를 생성합니다.
- 이 방식은 위험할 수 있습니다. 이미 다른 `std::shared_ptr`에 의해 관리되고 있는 객체에 대해 `shared_ptr(this)`를 사용하면, 동일 객체에 대해 서로 독립적인 참조 카운트를 갖는 두 개의 `shared_ptr`이 생겨납니다. 이는 객체의 중복 해제로 이어져 메모리 오류를 일으킬 수 있습니다.
- `shared_ptr(this)` 사용은 객체가 `std::shared_ptr`에 의해 아직 관리되고 있지 않을 때, 즉 객체의 생성과 동시에 첫 `std::shared_ptr`을 만들 때만 안전합니다.

---

🗣️ C++의 lock, mutex, lockguard, shared_mutex, shared_lock, unique_lock 에 대해 아는대로 설명해주세요.

🔒 mutex 는 자물쇠, 🗝️ lock 은 열쇠 라고 비유할 수 있습니다.

 

C++에서는 멀티스레딩 환경에서의 race condition 을 방지하기 위해

`lock`, `mutex`, `lock_guard`, `shared_mutex`, `shared_lock`, `unique_lock` 등의 동기화 메커니즘을 제공합니다.

`mutex`

상호 배제(mutual exclusion)를 위한 기본적인 도구입니다. 한 번에 하나의 스레드만이 `mutex`를 소유(잠금)할 수 있으며, 다른 스레드들은 소유 스레드가 `mutex`를 해제(잠금 해제)할 때까지 기다려야 합니다.
`lock()`과 `unlock()` 메서드를 사용하여 잠금 및 잠금 해제를 수행합니다. lock 은 한 번에 여러 뮤텍스를 안전하게 잠글 수 있습니다.

`lock_guard`

RAII(Resource Acquisition Is Initialization) 패턴을 사용하여 `mutex`의 생명주기를 관리합니다. 생성될 때 `mutex`를 잠그고, 파괴될 때 자동으로 잠금을 해제합니다. `mutex`와 함께 `lock_guard` 객체를 생성하면 됩니다. 스코프를 벗어날 때 자동으로 잠금이 해제됩니다.

`unique_lock`

`lock_guard`보다 더 유연합니다. `lock()`과 `unlock()`을 수동으로 호출할 수 있으며, 락을 이전할 수도 있습니다. `condition_variable`과 함께 사용할 때 유용합니다. 생성 시에 `mutex`를 잠그거나, 나중에 `lock()` 메서드를 사용하여 잠금을 수행할 수 있습니다.

`shared_mutex`

여러 스레드가 동시에 읽기 작업을 수행할 수 있도록 허용하면서, 쓰기 작업은 한 번에 하나의 스레드만 수행할 수 있도록 합니다.
`lock_shared()`와 `unlock_shared()`를 사용하여 여러 스레드가 동시에 읽을 수 있게 하고, `lock()` 및 `unlock()`을 사용하여 쓰기 작업을 수행합니다.

`shared_lock`

`shared_mutex`에 대한 공유 잠금을 관리합니다. 여러 스레드가 동시에 `shared_mutex`를 읽기 전용으로 잠글 수 있습니다.
`shared_lock` 객체를 생성하여 `shared_mutex`를 공유 모드로 잠급니다.

즉 `mutex`와 `lock_guard`는 기본적인 상호 배제를 제공하는 반면, `unique_lock`과 `shared_lock`은 더 유연한 잠금 관리를 제공합니다. `shared_mutex`는 읽기와 쓰기 작업이 동시에 발생하는 상황에서 특히 유용합니다. 각각의 도구는 특정 상황과 요구 사항에 따라 선택되어야 합니다.

---

🗣️ static 이 무엇인가요?

 

`static`은 변수와 함수의 생명 주기와 사용 범위를 지정하는 방식 중 하나로서, `static`으로 선언된 변수와 함수의 생명 주기는 "프로그램이 시작할 때 생성되고, 프로그램이 종료할 대 소멸"하는 것입니다. 변수나 함수가 선언된 범위 내에서 사용되며 전역, 지역으로 구분됩니다.

 

`static` 멤버 함수는 오직 `static` 멤버 변수에 접근하거나 `static` 멤버 함수만 호출할 수 있습니다. 

`static` 멤버 함수는 객체가 생성되지 않은 어떤 시점에서도 호출될 수 있고, 클래스 이름으로 직접 호출될 수 있으므로, `static` 멤버 함수에서 `non static` 멤버에 접근하는 것은 허용되지 않습니다.

 

전역, 정적 변수는 프로그램의 시작 지점에 0 또는 NULL로 자동 초기화됩니다. 이는 프로그램의 실행 영역인 .data 및 .bss 세그먼트에 위치하고, 시스템에 의해 초기화됩니다.

---

🗣️ shared_ptr 는 왜 수동 관리 문제를 해결하나요? 그리고 정말로 스레드 안전한가요?

 

참조 카운트가 지원되는 포인터이며, 그런 포인터에 대한 참조 카운팅을 알아서 관리해주므로 수동 관리에서 발생할 수 있는 여러 문제를 해결합니다.

 

특정 측면에서 스레드 안전합니다. 그러나 모든 상황에서 완벽한 스레드 안전성을 제공하지는 않습니다.

- `shared_ptr`의 참조 카운트 조작은 atomic한 연산으로 수행되어, 여러 스레드에서 `shared_ptr` 객체를 복사하거나 할당할 때 안전합니다. 즉, 참조 카운트의 증가와 감소는 스레드 안전합니다.

- 그러나 `shared_ptr`가 가리키는 객체에 대한 접근은 스레드 안전하지 않습니다. 여러 스레드가 동일한 `shared_ptr`가 가리키는 객체에 동시에 접근하려면, 이 객체에 대한 접근을 별도로 동기화해야 합니다 (예: 🔒 뮤텍스 사용)

---

🗣️ shared_ptr 에서 순환 문제란 뭔가요 어떻게 해결하죠?

 

서로를 참조하고 있을 때 소멸자가 영원히 호출되지 않아서 양쪽이 해제되지 않는, 데드락과 비슷한 상황에 처하는 것입니다. 메모리 누수가 발생할 수 있습니다.

 

`weak_ptr`를 사용하면 객체의 생명주기에 영향을 주지 않고 참조 카운트 블록만 유지할 수 있습니다.

---

🗣️ map, vector 비교해주세요

 

`map`은 검색이 O(logN) 시간복잡도에 이르는 절대적으로 빠른 컨테이너이지만

순회가 주 기능이고 검색이 필요없다면, `vector`를 사용하는 것이 낫습니다.

---

Reference

 

https://comfun.tistory.com/entry/c-c-%EB%A9%B4%EC%A0%91

https://cclient.tistory.com/11

https://velog.io/@kkanyo/%EA%B8%B0%EC%88%A0%EB%A9%B4%EC%A0%91-C-%EC%9A%94%EC%95%BD-%EC%A0%95%EB%A6%AC-%EA%B3%84%EC%86%8D-%EC%88%98%EC%A0%95

https://se-jung-h.tistory.com/entry/C-C-%EA%B8%B0%EC%88%A0-%EB%A9%B4%EC%A0%91-%EC%A7%88%EB%AC%B8

https://developstudy.tistory.com/62