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

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

 

C++ 빌드 과정

1. 전처리 (Preprocessing):
   • 이 단계에서는 소스 파일(.cpp 파일)이 전처리기에 의해 처리됩니다.
   • 전처리기 지시문 (#include, #define, #if, 등)이 실행되어 코드에 포함됩니다. 예를 들어, #include 지시문은 해당 헤더 파일의 내용을 소스 파일에 복사합니다.
   • 이 단계에서의 출력은 "전처리된 소스 코드"이며, 보통은 사람이 읽기 어려운 형태입니다.
2. 컴파일 (Compilation):
   • 전처리된 소스 코드는 컴파일러에 의해 기계어로 번역됩니다.
   • 컴파일러는 각 소스 파일(.cpp)을 오브젝트 파일(.obj 또는 .o)로 변환합니다.
   • 이 단계에서는 구문 분석, 의미 분석, 코드 최적화 등이 수행됩니다.
3. 어셈블리 (Assembly):
   • 컴파일 단계에서 생성된 오브젝트 파일들은 기계어 코드(어셈블리어)를 포함하고 있습니다.
   • 어셈블리 단계는 일반적으로 컴파일 단계에 내장되어 있으며, 별도의 단계로 분리되지 않는 경우가 많습니다.
4. 링킹 (Linking):
   • 컴파일러가 생성한 오브젝트 파일들이 링커에 의해 하나의 실행 파일로 결합됩니다.
   • 링커는 각 오브젝트 파일들 간의 의존성을 해결하고, 필요한 라이브러리 코드를 포함시켜 실행 가능한 파일(예: .exe 또는 .out)을 생성합니다.
   • 이 단계에서 외부 라이브러리 함수에 대한 참조, 전역 변수의 메모리 할당 등이 이루어집니다.

---

C++ 컴파일 과정

C++의 컴파일 과정은 소스 코드가 기계어로 번역되는 일련의 단계를 포함합니다. 이 과정은 복잡한 소프트웨어 프로젝트를 실행 가능한 형태로 변환하는 데 필요합니다. 주요 단계는 다음과 같습니다:

1. 전처리 (Preprocessing):
   • 전처리기는 소스 파일(.cpp 파일)을 처리합니다.
   • 전처리 지시문 (예: #include, #define, #if 등)이 실행됩니다. #include는 해당 헤더 파일의 내용을 소스 파일에 삽입하고, 매크로 정의나 조건부 컴파일 지시문은 해당 조건에 따라 코드를 조정합니다.
   • 이 단계의 결과는 전처리된 코드이며, 이는 다음 단계에서 컴파일러에 의해 처리됩니다.
2. 컴파일 (Compilation):
   • 전처리된 소스 코드는 컴파일러에 의해 기계어로 변환됩니다.
   • 컴파일러는 소스 파일(.cpp)을 오브젝트 파일(.obj 또는 .o)로 변환합니다. 이는 아직 실행 가능한 프로그램이 아닙니다.
   • 이 단계에서 구문 분석(Syntax Analysis), 의미 분석(Semantic Analysis), 중간 코드 생성(Intermediate Code Generation), 최적화(Optimization) 등의 과정이 수행됩니다.
3. 링킹 (Linking):
   • 컴파일 단계에서 생성된 오브젝트 파일들은 링커에 의해 하나의 실행 파일로 결합됩니다.
   • 링커는 오브젝트 파일들 간의 의존성을 해결하고, 필요한 라이브러리 코드를 포함시켜 최종적인 실행 가능한 파일(예: .exe 또는 .out)을 생성합니다.
   • 이 단계에서는 외부 라이브러리 함수에 대한 참조 해결, 전역 변수의 메모리 할당 등이 이루어집니다.

C++ 컴파일러는 이러한 각 단계를 통해 고수준의 소스 코드를 저수준의 기계어 코드로 변환하는 복잡한 작업을 수행합니다. 컴파일 과정의 정확한 세부 사항은 사용하는 컴파일러의 종류(예: GCC, Clang, MSVC 등)와 설정에 따라 다를 수 있습니다.

---

endl, \n 차이

C++에서 endl과 \n은 둘 다 줄바꿈을 수행하지만, 그들 사이에는 중요한 차이가 있습니다. 이 차이는 주로 버퍼 플러시와 관련이 있습니다.

1. \n (Newline Character):
   • \n은 단순히 줄바꿈 문자입니다.
   • 이 문자는 문자열 내에서 새로운 줄을 시작하도록 지시합니다.
   • 출력 스트림에 \n을 사용하면 현재 위치에서 줄을 바꾸지만, 출력 버퍼를 플러시하지는 않습니다. 즉, 버퍼의 내용이 즉시 출력 장치로 전송되지 않을 수 있습니다.
   • 버퍼가 플러시되지 않는다는 것은 출력이 지연될 수 있고, 프로그램이 강제 종료되었을 때 일부 출력이 손실될 수 있다는 의미입니다.
2. std::endl (End Line):
   • std::endl은 줄바꿈을 수행하고 출력 버퍼를 플러시합니다.
   • std::endl을 사용하면 현재 스트림 버퍼의 모든 내용이 즉시 출력 장치로 전송되고, 새로운 줄로 이동합니다.
   • 버퍼 플러시는 출력의 즉각적인 표시를 보장하지만, 빈번한 플러시는 성능 저하를 일으킬 수 있습니다. 각 std::endl 호출마다 버퍼를 플러시하기 때문에, 빠른 속도로 많은 양의 데이터를 출력해야 하는 상황에서는 성능 저하의 원인이 될 수 있습니다.

선택 기준

• 성능을 중시하는 경우: 대량의 데이터를 빠르게 출력해야 할 때는 \n을 사용하는 것이 좋습니다. \n은 버퍼를 자동으로 플러시하지 않기 때문에 성능상 이점이 있습니다.
• 출력의 즉각적인 표시가 중요한 경우: 프로그램의 로그를 출력하거나 사용자에게 즉시 피드백을 제공해야 하는 상황에서는 std::endl을 사용하여 버퍼를 즉시 플러시하는 것이 좋습니다.

일반적으로, \n은 성능을 중시하는 상황에, std::endl은 출력의 정확성과 즉각성이 중요한 상황에 적합합니다.

---

아스키문자란? 현대에선 어떻게 쓰이나?

아스키(ASCII, American Standard Code for Information Interchange) 문자는 컴퓨터에서 텍스트를 표현하기 위해 사용되는 문자 인코딩 체계입니다. 1960년대에 개발된 이 인코딩은 영어 알파벳, 숫자, 일부 특수 문자, 그리고 제어 문자를 나타내는 데 사용됩니다.

아스키 문자의 특징

• 아스키 문자 집합은 총 128개의 문자로 구성되어 있으며, 각 문자는 7비트로 표현됩니다.
• 이 문자 집합에는 대문자와 소문자 영문 알파벳(A-Z, a-z), 숫자(0-9), 표준 특수 문자(예: !, @, #, $, 등), 그리고 제어 문자(예: 줄바꿈, 탭 등)가 포함됩니다.

현대에서의 사용

아스키는 초기 컴퓨터 시스템에서 기본적인 문자 인코딩으로 널리 사용되었으며, 현재도 많은 시스템과 프로토콜에서 기본적인 텍스트 인코딩으로 사용되고 있습니다. 그러나 현대에는 몇 가지 중요한 이유로 인해 아스키보다 더 진보된 문자 인코딩 체계가 널리 사용됩니다:

1. 다국어 지원: 아스키는 주로 영어를 위해 설계되었기 때문에 다양한 언어와 문자를 지원하는 데 한계가 있습니다. 이를 극복하기 위해 UTF-8, UTF-16과 같은 유니코드 인코딩 체계가 개발되었으며, 이들은 전 세계의 다양한 언어와 문자를 지원합니다.
2. 확장성: 아스키는 상대적으로 제한된 수의 문자만을 지원합니다. 유니코드와 같은 확장된 인코딩 체계는 훨씬 더 많은 문자와 기호를 포함할 수 있어, 다양한 기술적 요구 사항을 충족시킬 수 있습니다.
3. 호환성: 많은 현대 시스템과 프로그래밍 언어는 유니코드를 기본 인코딩으로 사용하며, 아스키 문자 집합은 유니코드와 호환됩니다. 예를 들어, UTF-8 인코딩은 아스키 문자 집합의 범위 내에서는 아스키와 동일한 바이트 값을 사용합니다.

결론적으로, 아스키는 현대 컴퓨터 시스템에서 여전히 기본적인 텍스트 인코딩으로 사용되고 있으나, 다국어 지원과 확장성을 위해 유니코드 인코딩 체계가 점점 더 선호되고 있습니다.

---

🗣️ 객체 지향 프로그래밍이란 무엇인지 설명해 주실래요? 

 

객체 지향이란 컴퓨터 프로그래밍 패러다임 중 하나로, 프로그래밍에서 필요한 데이터를 추상화시켜 상태와 행위를 가진 객체를 만들고 그 객체들 간의 유기적인 상호작용을 통해서 로직을 구성하는 방법입니다. 

 

순차적으로 처리되는 절차형 프로그래밍의 한계점에 의해 탄생한 프로그래밍 기법이다. 

• C와 C++ 차이 : 절차지향 프로그래밍 (기능 중심) / 객체지향 프로그래밍 (데이터 중심)
  • 차이점 : C++은 오버라이딩, 예외처리, 제네릭 프로그래밍, namespace, 객체 중심 사용 가능 https://nextcoder.tistory.com/39

추상화 캡슐화 상속성 다형성이라는 네 가지 특성이 있습니다. 

• 추상화: 객체의 공통적인 특성을 추출하는 것으로, 변수 또는 메서드를 하나로 묶어 단순화하는 것이구요.
• 캡슐화: 객체 내부에 직접 접근하지 않고 공개된 인터페이스를 통해서만 객체에 접근해 조작하도록 한다. 정보 은닉을 통해 내부적으로 높은 응집도를 가지고 외부에선 낮은 결합도를 가집니다.
• 상속성: 기존 클래스를 기반으로 새로운 클래스를 정의하는 것으로, 공통된 특성을 하나의 개념으로 정립하는 것을 말합니다. 이를 통해 코드 재사용성을 높이고 확장성을 개선할 수 있습니다.
• 다형성: 동일한 인터페이스에 대해 다른 기능을 제공하는 것입니다. 주로 오버로딩과 오버라이딩을 통해 구현됩니다.

---

🗣️ 다형성이 필요한 이유에 대해 설명해주실래요? 

 

다형성은 상속을 통해 기능을 확장하거나 변경하는 것을 가능하게 해주고, 같은 클래스 내에 코드의 길이를 줄여줍니다.

 

다형성 발생은, 객체 포인터, 오버라이딩, `virtual` 키워드는 각각 따져봤을 때 다형성이 발생되진 않지만, 세 개가 합쳐질 때 다형성이 발생됩니다.

---

🗣️ 컴파일 타임 다형성과 런타임 다형성의 차이점은 무엇이며, C++에서 어떻게 구현되나요?

 

이 두 방법은 다형성을 실현하는 시점과 방식에서 차이가 있습니다.

컴파일 타임 다형성은 프로그램이 컴파일되는 시점에 다형성이 결정되는 것을 의미합니다.

주로 함수 오버로딩과 템플릿을 사용하여 구현됩니다. 함수 오버로딩은 같은 이름의 함수를 매개변수의 타입이나 개수를 다르게 하여 여러 번 정의하는 것입니다. 템플릿을 사용하면 함수나 클래스를 타입에 독립적으로 정의할 수 있습니다.
컴파일러는 코드를 컴파일하는 시점에 어떤 함수나 템플릿 인스턴스를 사용할지 결정합니다.

void print(int i) { /* ... */ }
void print(double f) { /* ... */ }

template <typename T>
void printArray(T* arr, int size) { /* ... */ }

런타임 다형성은 프로그램이 실행되는 동안에 다형성이 결정되는 것을 의미합니다.
주로 가상 함수(Virtual Functions)를 사용하여 구현됩니다. 기반 클래스에 `virtual` 키워드로 선언된 함수는 파생 클래스에서 오버라이딩(재정의)될 수 있습니다. 런타임에 객체의 실제 타입에 따라 호출될 함수가 결정됩니다. 이는 주로 포인터나 참조를 통해 다형적 객체를 다룰 때 발생합니다.

class Base {
	virtual void print() { /* ... */ }
};

class Derived : public Base {
	void print() override { /* ... */ }
};

Base* b = new Derived();
b->print(); // 런타임에 Derived의 print 함수가 호출됨

컴파일 타임 다형성은 코드의 효율성과 최적화 측면에서 유리하며, 런타임 다형성은 유연성과 확장성 측면에서 강점을 가집니다. C++에서 이 두 가지 다형성을 적절히 사용함으로써, 코드의 재사용성과 유지보수성을 높일 수 있습니다.

---

🗣️ 객체 지향의 5대 원칙이 무엇인가요?

 

출처 https://mangkyu.tistory.com/194

 

SOLID Principles 에 대해 말씀드리겠습니다. 

 

S (Single Responsibility Principle) 단일 책임 원칙

• 한 클래스는 하나의 책임만 가져야 한다.
• 여기서 책임이란 '변경의 이유'를 의미하며, 클래스가 변경되어야 하는 이유는 단 하나여야 합니다. 
• 해당 모듈이 여러 대상에 대해 책임을 가져서는 안되고, 오직 하나의 대상에 대해서만 책임을 져야 합니다.

O (Open-Closed Principle) 개방 폐쇄 원칙

• 확장에는 열려 있으나, 변경에는 닫혀 있어야 한다.
• 즉, 기존의 코드를 변경하지 않고도 클래스의 기능을 확장할 수 있어야 합니다.

L (Liskov Substitution Principle) 리스코프 치환 원칙

• 파생 클래스는 기반 클래스의 기능을 대체할 수 있어야 합니다.
• 기반 클래스의 인스턴스를 파생  클래스의 인스턴스로 대체해도, 시스템의 정확성이나 행동이 변하지 않아야 합니다.

I (Interface Segregation Principle) 인터페이스 분리 원칙

• 특정 클라이언트를 위한 인터페이스 여러 개가 범용 인터페이스 하나보다 낫다.
• 한 클래스는 자신이 사용하지 않는 인터페이스는 구현하지 않아야 합니다.

D (Dependency Inversion Principle) 의존성 역전 원칙

• 추상화에 의존한다.
• 추상화는 구체적인 세부 사항에 의존해서는 안 됩니다. 오히려 세부 사항이 추상화에 의존해야 합니다.

---

🗣️ 포인터와  참조의 공통점, 차이점, 사용처에 대해 아는대로 설명해 주실래요?

 

공통점

복사 비용을 줄이고 싶을 때, 간접적으로 객체에 접근해서 원격으로 원본을 건드리고 싶을 때 사용한다는 점입니다. 

 

차이점

• 포인터는 NULL 값이 허용되며, 재할당이 가능해서 다른 주소를 가리킬 수 있습니다.
• 참조는 항상 유효한 객체를 가리켜야 하므로 선언 시 반드시 초기화되어야 하며, 한 번 초기화되면 다른 객체를 가리킬 수 없습니다. 또한 NULL 값으로 초기화될 수 없습니다.

언제 각각을 사용하는 것이 좋은가요?

• 포인터는 동적 할당, 선택적 접근, 데이터 구조 (예: 연결 리스트, 트리) 등에 주로 사용됩니다.
• 참조는 함수의 매개변수나 반환 값으로 사용할 때, 그리고 클래스 내부에서 객체 또는 데이터를 참조할 때 선호됩니다.

---

🗣️ 가상 함수에 대해 아는대로 설명해 주실래요?

 

C++에서 virtual 키워드를 사용하는 가상 함수는 다형성을 구현하게 해줍니다. 이러한 가상 함수의 목적은 runtime에 함수의 바인딩을 결정하는 것입니다. 이를 통해 파생 클래스에서 기본 클래스의 메서드를 오버라이딩하고, 기본 클래스의 포인터나 참조를 통해 해당 메서드를 호출할 때 파생 클래스의 구현을 실행할 수 있습니다. 이 과정은 동적 바인딩이라고 합니다.

 

C++ 컴파일러는 가상 함수를 하나라도 포함하는 클래스에 대해  `4 byte` 크기의 가상 함수 테이블(vftable)을 생성합니다. 이 테이블은 클래스별로 하나씩 생성되며, 클래스 내의 모든 가상 함수 주소를 포함합니다. 이 가상 함수 테이블은 클래스의 모든 인스턴스에 의해 공유되는 구조입니다. 객체가 생성될 때, 각 객체 인스턴스는 가상 함수 테이블의 시작 주소를 가리키는 포인터인 vptr 를 내부에 저장하며, 이 포인터는 객체의 타입에 따라 해당 클래스의 가상 함수 테이블에서 어느 주소에 있는 함수가 호출되어야 하는지를 결정합니다. 

 

만약 하위 클래스가 상위 클래스의 가상 함수를 오버라이드하지 않으면 하위 클래스의 가상 테이블은 상위 클래스의 가상 함수 주소를 보관합니다. 

---

🗣️ 모든 함수를 가상 함수로 쓰면 안되나요?

 

모든 함수들을 디폴트로 가상 함수로 만듬으로써, 언제나 동적 바인딩이 제대로 동작하게 만들 수 있습니다. 실제로 Java 의 경우 모든 함수들이 디폴트로 `virtual` 함수로 선언됩니다.

 

그럼에도 불구하고 C++ 에서 사용자가 직접 선언하도록 한 이유는, 가상 함수를 사용하게 되면 약간의 오버헤드 (overhead) 가 존재하기 때문입니다. 가상 함수 테이블을 한 단계 더 거쳐서 실제로 어떤 함수를 고를지 결정하는 과정입니다.

 

그래서 가상 함수를 호출하는 경우, 일반적인 함수보다 약간 더 시간이 오래 걸리게 됩니다. 물론 이 차이는 극히 미미하지만, 최적화가 매우 중요한 분야에서는 이를 감안할 필요가 있습니다. C++ 에서는 다른 언어들과는 다르게, 멤버 함수가 디폴트로 가상함수가 되지 않습니다.

 

참고 https://modoocode.com/211

---

🗣️ 상속 환경에서 소멸자를 어떻게 다뤄야 하는지 설명해 주세요. 💡

 

클래스 내부에서 메모리를 동적 할당하는 경우 소멸자에서 메모리를 해제해주는데요,상속받은 부모의 소멸자가 가상 소멸자가 아닌 경우, 실제 객체의 클래스가 아닌 생성된 포인터 자료형에 따라 소멸자가 호출됩니다. 결국 부모 클래스의 소멸자만 호출되고 메모리 누수가 발생합니다. 하여 다형성을 지원할 수 있는 기본 클래스의 경우에는 소멸자를 꼭 가상함수로 지정해야 합니다.

 

참고하면 좋을 블로그 https://song-ift.tistory.com/m/55 , https://modoocode.com/211

---

🗣️ '더블 프리'나 '댕글링 포인터', '메모리 누수'는 어떤 상황에서 생기나요?

 

더블 프리 (Double Free): 메모리가 이미 해제된 후, 같은 메모리 주소에 대해 `delete`나 `free`를 다시 실행 할 때 발생합니다. 

 

댕글링 포인터 (Dangling Pointer): 이미 해제되었거나 유효하지 않은 메모리 영역을 가리키는 포인터 를 말합니다. 예를 들어, 객체가 소멸된 후에도 해당 객체를 가리키는 포인터를 사용하려고 할 때 발생합니다. 

 

메모리 누수 (Memory Leak): 동적으로 할당된 메모리가 프로그램에 의해 제대로 해제되지 않을 때 발생합니다. 프로그램이 실행되는 동안 지속적으로 불필요한 메모리를 점유하게 되며, 이는 시스템 자원의 낭비로 이어질 수 있습니다.

 

C++에서 메모리 누수를 방지하기 위한 방법으로는 RAII 패턴을 사용하여 동적 메모리를 관리하는 법이 있습니다. 객체의 생성자에서 리소스를 할당하고, 소멸자에서 자동으로 리소스를 해제하는 방식입니다. 예를 들어, 스마트 포인터가 있습니다.

---

🗣️ malloc, new 차이점이 뭘까요?

 

둘 다 동적으로 Heap 공간에 메모리를 할당하기 위해서 사용되는 점이 공통점인데요, 또한 Garbage Collector 가 없으므로, 사용자가 수동으로 동적할당한 메모리를 수거해야 한다는 점도 공통적입니다.

 

`malloc`은 C에서부터 사용된 것이고 `new`는 C++에서 새로 추가된 것입니다. 

그리고 `malloc`/`free`는 함수, `new`/`delete`는 연산자 (operator) 입니다. 그리고 중요한 차이는 생성자 호출의 유무입니다. 

 

`malloc`/`free`

• 라이브러리 제공 함수로, `#include "stdlib.h"` 를 해줘야 사용 가능합니다.
• `malloc` 는 `byte` 단위의 사이즈를 매개변수로 받고, 리턴타입이 `void*`형이므로 반환받은걸 해당 타입의 포인터로 형변환(캐스팅) 을 해줘야 합니다
• 메모리를 동적으로 할당하는 것만이 목적이므로 생성자를 호출할 수단이 없기에 초기값을 줄 수 없다는 단점이 있습니다.
• 역시 `free` 의 경우에도 소멸자를 부르는게 아닌 함수 호출입니다.
• 오로지 POD(Plain Old Data) 타입에 대해서만 크기를 할당해줄 수 있습니다.
• `malloc` 으로 할당한 경우에는 `realloc`을 활용해 메모리 크기를 조정할 수 있습니다.
  • 하지만 `new`에는 할당된 크기에 대한 메모리 재조정이 불가능해서 `새로 할당, 복사, 해제` 하는 과정을 거쳐야 합니다. 하지만 객체의 경우 반드시 `new`/`delete` 를 사용해서 할당, 해제 해주어야 합니다. 생성자의 역할이 없고 초기화를 해주지 않아서 쓰레기값이 들어가기 때문입니다. 따라서 객체가 아닌 경우에 재할당이 빈번히 일어난다면, `malloc`/`free`가 더 좋은 선택이 될 수 있습니다. 
  • `malloc()`, `calloc()`, `realloc()` 의 차이점은 무엇인가요?
    • `malloc()`은 지정된 크기의 메모리 블록을 할당하고, 초기화하지 않은 상태로 그 메모리 블록의 주소를 반환합니다. 할당된 메모리에는 쓰레기 값이 남아있을 수 있습니다.
      `calloc()`은 지정된 수의 요소에 대해 지정된 크기만큼 메모리를 할당하고, 모든 비트를 `0`으로 초기화합니다. 이는 주로 배열이나 여러 개의 객체를 할당할 때 사용됩니다.
      `realloc()`은 이미 할당된 메모리 블록의 크기를 변경합니다. 새로운 크기가 기존 크기보다 크면, 추가된 부분은 초기화되지 않은 상태로 남습니다. 또한, 필요에 따라 새로운 메모리 위치로 블록을 이동할 수 있으며, 이 경우 원래 메모리는 해제됩니다.
      즉, `malloc()`과 `calloc()`은 메모리 할당에 사용되지만, `calloc()`은 메모리를 0으로 초기화하는 반면, `malloc()`은 초기화하지 않습니다. `realloc()`은 할당된 메모리의 크기를 조정하는 데 사용됩니다.
  • `realloc()`의 대표적 문제는 무엇인가요?
    • 정말 혹시나 메모리 할당이 실패할 경우 `null`이 반환되기 때문에 기존의 메모리가 할당되어 있는 포인터를 잃어버리는 것입니다. 이런 점은 메모리 누수로 남습니다. 그래서 `realloc` 시 기존 메모리 주소를 저장하고 실패 시 복구하는 프로세스가 함께 있어야 한다.
  • 그렇다면 생성자에서 생성 시 초기화를 한다고 했는데, 그건 어떻게 하는걸까요?
    • 초기화 리스트, 대입의 차이가 있는데요, 즉 생성 시 초기화와 생성 후 초기화로 나뉠 수 있는 것입니다. 생성 후 초기화보다 생성 시 초기화가 효율이 더 좋습니다. 초기화 리스트를 사용하면 멤버 변수를 생성과 동시에 초기화할 수 있습니다. 임시 객체 생성 없이 직접 초기화하기 때문에 성능상 이점을 제공합니다.
    • 또한 상수(const)나 참조(&) 멤버 변수는 반드시 초기화 리스트를 사용해야 합니다. 이들은 대입을 통해 초기화될 수 없기 때문입니다.
      • 생성자 본문에서는 참조 멤버에 값을 할당할 수 없습니다. 참조는 한 번 초기화되면 다른 객체를 참조하도록 변경할 수 없기 때문입니다.
      • 상수 멤버는 생성된 후 값을 변경할 수 없으므로, 생성자 본문에서 초기화하는 것이 불가능합니다.

`new`/`delete`

• `new`/`delete` 는 기본적으로 C++ 내 있는 키워드로 별도의 라이브러리 추가가 없습니다.
• `new` 의 경우 할당할 변수의 자료형을 지정하면, 반환값이 해당 타입의 포인터로 자동 반환이 되므로 직접 사이즈를 입력하지 않아도 됩니다. 
• 클래스 객체를 동적 할당하게 되면 생성자를 자동으로 호출해서, 할당과 동시에 초기화가 가능합니다.
• `delete` 는 소멸자를 호출하여 메모리를 해제합니다. 즉 `free`와 `delete`는 메모리를 해제하는 것은 동일하지만 `delete`는 소멸자를 호출한다는 점이 차이점입니다.
• `new` 로 할당한 경우 직접적으로 메모리 크기를 조정할 수 없습니다.
• 때문에 재할당이 많다면 `malloc` 이 더 나은 방법이 될 수도 있습니다.

참고하면 너무너무 좋을 블로그: https://woo-dev.tistory.com/123

---

🗣️ 순수 가상 함수와 추상 클래스의 차이점이 무엇인가요?

 

C++에서 인터페이스의 역할은 주로 추상 클래스 (abstract class) 를 통해 구현됩니다. 추상 클래스는 하나 이상의 순수 가상 함수(pure virtual function)를 포함하는 클래스입니다. 순수 가상 함수는 함수 본체가 정의되지 않은 가상 함수로, 파생 클래스에서 반드시 오버라이드(재정의)되어야 합니다.

+ 이 추상클래스는 실행 코드가 없는 순수 가상 함수를 가지고 있으므로 불완전한 클래스라서, 영원히 인스턴스를 만들지 못합니다. 계층적 상속 관계를 가진 클래스 간 구조를 만들 때 적합합니다. 

---

🗣️ 순수 가상 함수와 일반 가상 함수의 차이가 있나요?

 

순수 가상 함수는 무조건 재정의를 해줘야 하지만,

일반 가상함수는 재정의를 하지 않아도 되기 때문에 프로그램상에서 오류로 보지 않습니다.

---

🗣️ 스마트 포인터에 대해 아는대로 설명해주실래요? 그리고 어떻게 생각하시나요? 사용 경험이 있으신가요?

 

C++의 표준 라이브러리에서 제공하는 클래스 템플릿으로, 자동으로 메모리를 관리해주는 역할을 합니다. RAII (Resource Acquisition Is Initialization) 패턴을 기반으로 작동하여, 객체가 스코프를 벗어날 때 자동으로 메모리를 해제합니다.

총 세 가지가 있는데, `unique_ptr`는 자원의 단독 소유, `shared_ptr`는 자원의 공유 소유, `weak_ptr`는 `shared_ptr`의 순환 참조 문제 해결에 사용됩니다.

 

`shared_ptr` 는 참조 카운팅을 사용하여 여러 스마트 포인터가 동일한 객체를 공유할 수 있게 합니다. 하나의 특정 객체를 참조하는 스마트 포인터가 총 몇 개인지를 참조하는 스마트 포인터입니다. 참조 횟수가 `0`이 되면 `delete` 키워드를 사용해 자동으로 해제됩니다. 복사 및 할당을 통해 쉽게 공유될 수 있습니다.

 

`weak_ptr` 는 shared_ptr와 함께 사용되며, 공유 객체에 대한 약한 참조를 제공합니다. 참조 카운트를 증가시키지 않아 순환 참조 문제를 방지할 수 있습니다. shared_ptr가 가리키는 객체에 접근할 수 있지만, 객체의 생명 주기를 관리하지는 않습니다.

 

`unique_ptr` 는 하나의 스마트 포인터만이 특정 객체를 소유할 수 있도록 객체에 소유권 개념을 도입한 스마트 포인터입니다. 소유권 이전은 가능하지만 복사는 불가능합니다 (std::move를 사용하여 소유권을 이전할 수 있음).

 

OOO프로젝트에서 OOO기능을 구현할 때 OOO문제를 예방하기 위해 사용했습니다.

---

🗣️ RAII(Resource Acquisition Is Initialization) 패턴이란 무엇이며, C++에서 이를 어떻게 사용하나요?

 

RAII (Resource Acquisition Is Initialization)는 C++에서 자주 사용되는 프로그래밍 원칙으로, 자원을 획득하는 동시에 객체를 초기화하며, 객체의 수명이 끝나면 자원을 자동으로 해제하는 패턴입니다. 이 원칙의 목적은 메모리 누수, 자원 누수, 예외 안전성 등을 관리하여 안정적이고 예측 가능한 코드를 작성하는 데 있습니다.

 

RAII 패턴에 대해 더 구체적으로 말씀드리겠습니다.

• 자원을 할당하는 클래스의 생성자에서 자원을 획득(acquire)합니다.
• 클래스의 소멸자(destructor)에서 자원을 해제(release)합니다.
• 이러한 방식으로, 객체의 수명과 자원의 수명을 연결시킵니다.

RAII 패턴이 사용되는 예로는 smart pointer와 lock guard가 있습니다.

`unique_ptr`, `shared_ptr` 같은 스마트 포인터 클래스는 객체가 소멸할 때, 스마트 포인터는 자동으로 할당된 메모리를 해제합니다.

`lock_guard`는 생성될 때 뮤텍스를 잠그고, 소멸될 때 자동으로 뮤텍스를 해제합니다. 

#include <iostream>
#include <memory>
class Test {
public:
    Test() { std::cout << "Test 생성" << std::endl; }
    ~Test() { std::cout << "Test 소멸" << std::endl; }
    void greet() { std::cout << "안녕하세요!" << std::endl; }
};
int main() {
    {
        std::shared_ptr<Test> ptr1 = std::make_shared<Test>(); // Test 생성
        {
            std::shared_ptr<Test> ptr2 = ptr1; // 참조 카운트가 2가 됩니다.
            ptr2->greet(); // 안녕하세요!
        } // ptr2가 범위를 벗어나면 참조 카운트가 1 감소합니다.
        
        ptr1->greet(); // 안녕하세요!
        // Test 소멸 // 함수 블록을 벗어나기 직전에 호출된다.
    } // ptr1이 범위를 벗어나면 참조 카운트가 0이 되고, 메모리가 자동으로 해제됩니다.

    return 0;
}
///////////////////////////////////////////////
#include <mutex>
std::mutex mtx;
void safe_function() {
    std::lock_guard<std::mutex> lock(mtx);
    // 여기에 안전한 코드 작성
    // lock_guard 객체가 소멸되면서 자동으로 mtx 뮤텍스를 해제합니다.
}

---

🗣️ `shared_ptr` 동작과정을 더 자세히 말해주시겠어요?

 

shared_ptr는 객체에 대한 참조 카운트를 유지합니다. 즉, 특정 객체를 가리키는 `shared_ptr`의 수를 추적합니다. 새로운 `shared_ptr`가 같은 객체를 가리킬 때마다 참조 카운트가 증가하고, `shared_ptr`가 소멸하거나 다른 객체를 가리키게 되면 참조 카운트가 감소합니다. 객체를 가리키는 `shared_ptr`가 더 이상 없을 때 (참조 카운트가 `0`이 될 때), 해당 객체는 자동으로 삭제됩니다.

이는 메모리 누수를 방지하고 자동 메모리 관리를 가능하게 합니다.

---

🗣️ `shared_ptr` 를 사용할 때 `this` 를 사용하는 방법이 뭔가요?

 

직접 `this` 포인터를 `shared_ptr`로 변환해서 사용하는 것은 권장되지 않습니다. 그 이유는 `this`를 사용하여 생성된 `std::shared_ptr`는 별도의 참조 카운트를 유지하게 되므로, 같은 객체에 대해 여러 개의 독립적인 참조 카운트가 존재하게 되서 메모리  문제를 야기할 수 있습니다.

이를 해결하기 위해 C++11 부터는 `enable_shared_from_this`클래스를 사용할 수 있습니다. 이 클래스를 상속받으면 클래스 내부에서 `shared_from_this()` 메서드를 통해 안전하게 `shared_ptr`를 얻을 수 있습니다. 이 방법을 사용하면 `this` 포인터가 가리키는 객체에 대한 `shared_ptr`가 이미 존재한다면, 해당 `shared_ptr`와 동일한 참조 카운트를 공유하는 새로운 `shared_ptr` 인스턴스를 얻을 수 있습니다.

#include <iostream>
#include <memory>

class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    std::shared_ptr<MyClass> getShared() {
        return shared_from_this();
    }
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = ptr1->getShared();

    // ptr1과 ptr2는 동일한 객체를 가리키며, 참조 카운트는 공유됩니다.
    std::cout << "ptr1.use_count() = " << ptr1.use_count() << std::endl; // 출력: 2
    std::cout << "ptr2.use_count() = " << ptr2.use_count() << std::endl; // 출력: 2

    return 0;
}

이 코드에서 `MyClass`는 `std::enable_shared_from_this<MyClass>`를 상속받습니다. `getShared` 함수는 `shared_from_this`를 사용하여 현재 객체에 대한 `shared_ptr`를 반환합니다. `main` 함수에서 `ptr1`과 `ptr2`는 동일한 객체를 가리키며, 참조 카운트를 공유합니다.

---

🗣️ 깊은 복사와 얕은 복사의 차이점이 뭘까요?

 

깊은 복사는 객체의 모든 값을 새로운 메모리 위치에 복사하는 반면, 

얕은 복사는 객체의 메모리 주소만 복사하여 두 객체가 같은 데이터를 공유하게 합니다.

 

깊은 복사는 멤버 변수 중 하나라도 동적 메모리 할당을 사용하는 경우, 또는 객체 간에 데이터 공유가 안전하지 않은 경우에 필요합니다.

얕은 복사를 사용하면 double free, 댕글링 포인터가 발생할 수 있습니다. 이러한 문제를 방지하기 위해

깊은 복사(deep copy)를 사용하거나, 스마트 포인터 같은 메모리 관리 기법을 활용하는 것이 좋습니다.

---

🗣️ 업캐스팅과 다운캐스팅에 대해 설명해주시겠어요?

 

업캐스팅과 다운캐스팅은 객체 지향 프로그래밍에서, 특히 상속 관계에 있는 클래스 사이의 형 변환 방식인데요.

업캐스팅은 자식 클래스의 객체를 더 큰 범주인 부모 클래스 타입으로 변환하는 것이며,

다운캐스팅은 부모 클래스의 객체를 자식 클래스 타입으로 변환하는 것입니다.

업캐스팅 예: `Dog` 클래스의 객체를 `Animal` 클래스 타입으로 변환 (Dog is a Animal)
다운캐스팅 예시: `Animal` 타입의 객체를 `Dog` 클래스로 캐스팅 (구체화/원복) 하여 `Dog` 특유의 특성 (메소드) 에 접근

 

업캐스팅 (Upcasting)
   - 업캐스팅은 자식 클래스의 객체를 부모 클래스의 객체로 변환하는 과정입니다. (Dog is a Animal)
   - 업캐스팅은 항상 안전하며 암시적으로 수행될 수 있습니다.
   - 업캐스팅을 통해 파생 클래스의 객체가 기반 클래스의 인터페이스를 사용할 수 있게 됩니다.

다운캐스팅 (Downcasting)

   - 다운캐스팅은 기반 클래스의 객체를 파생 클래스의 객체로 변환하는 과정입니다.
   - 다운캐스팅은 항상 안전하지는 않으며, 명시적으로 수행되어야 합니다 
   - 실제 객체가 변환하려는 파생 클래스 타입일 때만 안전하게 수행될 수 있습니다.

   - 잘못 사용하면 정보의 손실이 발생할 위험이 있어서, 이를 보완하기 위해 Dynamic Casting 이 존재합니다.

      - `dynamic_cast`는 런타임에 객체의 타입을 확인하여 안전한 캐스팅을 가능하게 합니다. 만약 캐스팅이 불가능하면 `nullptr`를 반환하여 오류를 방지합니다.

   - 생성할 때 쓸 수 없습니다. 단지 업캐스팅한 객체를 원래대로 되돌릴 때 사용할 뿐입니다.

#include <iostream>

class Base {
public:
    virtual void print() { std::cout << "Base class" << std::endl; }
};

class Derived : public Base {
public:
    void print() override { std::cout << "Derived class" << std::endl; }
    void specificFunction() { std::cout << "Specific function for Derived" << std::endl; }
};

int main() {
    Derived derived;

    // 업캐스팅: Derived -> Base
    Base* basePtr = &derived;
    basePtr->print(); // "Derived class"

    // 다운캐스팅: Base -> Derived
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
    if (derivedPtr) {
        derivedPtr->specificFunction(); // "Specific function for Derived"
    }

    return 0;
}

이 코드에서 `Derived` 클래스는 `Base` 클래스를 상속받습니다. `basePtr`는 업캐스팅을 통해 `Derived` 객체를 `Base` 포인터로 가리키고 있습니다. `derivedPtr`는 다운캐스팅을 사용하여 `Base` 포인터를 `Derived` 포인터로 변환합니다. 다운캐스팅이 안전하게 수행되면, `Derived` 클래스의 특정 기능을 사용할 수 있습니다.

 

+ RTTI 문법중에 사용한 것이 있다면 어떤것이 있었는지

dynamic-cast 와 static-cast 를 상황에 따라 사용했다.

부모클래스의 포인터에서 자식 클래스의 포인터로 다운캐스팅 할때 다이나믹 캐스트를 사용했다.

데이터 입출력을 통해 객체 안 데이터를 초기화할때나 가끔씩 발생하는 이벤트 시에 해당 객체의 데이터를 불러올 때 안전하게 dynamic-cast를 사용했고,

단순한 형변환이나 매 프레임마다 충돌같은 많은 비교연산을 할때는 런타임 비용이 낮은 static-cast를 사용했다. 

출처 https://song-ift.tistory.com/m/55

 

참고하면 좋을 블로그 : https://makefortune2.tistory.com/224

---

🗣️ C++ Casting 4가지 방식에 대해서 설명해보고 각각 어떻게 다른지를 얘기해주세요.

 

• `static_cast` : 컴파일 타임에, 타입 원칙에 비춰볼 때 논리적인 캐스팅만 허용해 줍니다. 단점으로는 이 논리적인 캐스팅이 항상 옳다는 것이 아니어서, 상속관계에 있는 클래스 간 타입변환을 잘못된 방식으로 캐스팅해주면, 메모리 오염이 일어날 수 있다는 것입니다. 따라서 `enum` 등 안전장치로 확인하는 코드 등이 필요합니다.
• `dynamic_cast` : `static_cast` 의 단점을 보충하는, 즉 런타임에 다형성을 가진 클래스의 상속 관계에서의 안전한 형 변환을 지원하는 캐스팅이라고 할 수 있습니다. 대신 `vftable` 로 원본을 확인하는 과정에서 `static_cast` 에 비해 오버헤드가 존재합니다. 변환 실패 시 `nullptr`를 반환합니다.
• `const_cast` : 객체의 상수성(constness)을 없애는 용도로 사용됩니다.
• `reinterpret_cast` : 위험하고 강력한 형태인데, 전혀 관계없는 다른 포인터로 형 변환할 수 있기 때문입니다.

+ 추가 질문 : const-cast를 사용해본 경험이 있었는지

const cast는 상수객체를 비상수화 객체로 변환해주는 캐스트인데 공부를 해서 알고는 있었지

사실 데이터를 처음 정의할 때 상수화로 정의를 하고 머리로 기억하고 있기때문에, 이 데이터를 수정해서 개념을 바꿔놓는 다는 것은 좀 위험할 것 같아서 사용안했다. https://song-ift.tistory.com/m/55

 

참고하면 좋을 블로그 https://uncertainty-momo.tistory.com/77, https://strawvery-devlog.tistory.com/33

---

🗣️ `static_cast`, `dynamic_cast` 는 어떻게 다른지를 얘기해주세요.

 

바인딩은 함수가 호출될 때 함수의 주소를 연결해 주는 것을 말합니다. 바인딩 시점에 따라서 정적 바인딩과 동적 바인딩으로 나뉘는데요, 정적 바인딩은 일반 기본 함수를 호출할 때 정적 바인딩이라 하고, 동적바인딩은 런타임 시점에 호출시킬 함수를 정해주는 것을 동적 바인딩이라 합니다. 대표적으로 가상함수가 있습니다.

 

`static_cast` 는 형 변환에 대한 타입을 런타임에 확인하지 않고 컴파일 타임에 정적으로 수행합니다. 

`dynamic_cast` 는 다형성을 활용하는 방식으로 RTTI (RunTime Type Information) 을 이용해서 런타임에 상속 계층 관계를 가로지르거나 다운캐스팅할 때 사용됩니다. 기본 클래스 객체에 대한 포인터나 레퍼런스 타입을 자식 클래스의 타입으로 변환할 수 있고 `nullptr`이거나 예외를 보고 실패를 판별할 수 있습니다. 또한, 동적 캐스트는 다형성을 띄지 않는 객체간 변환은 불가능하고 컴파일 에러가 발생합니다.

 

또한 정적으로 형변환을 해도 아무런 문제가 발생하지 않는 것은 이미 어떤 것인지 알고 있을 경우입니다. 동적으로 형변환을 시도한다는 것은 그것의 타입을 반드시 알아봐야 한다는 것을 의미합니다. 따라서 해당 타입에 대해 명확히 알고 있다면 정적 변환을 써서 비용을 절약하는 것이 좋습니다.

 

참고하면 좋을 블로그 https://drag0n.tistory.com/18

---

🗣️ 왼값 오른값. 뭐가 다르고 언제 필요한건가요?

 

왼값은 프로그램이 접근할 수 있는 주소가 있습니다. 변수 명, `const` 변수, 배열 요소, 왼값 참조를 반환하는 함수 등의 표현식이 있습니다. 오른값 표현식은 프로그램에서 액세스할 수 있는 주소가 존재하지 않습니다.

---

🗣️ 이동 의미론이 무엇인가요?

 

이동 의미론(Move Semantics) 은 C++11에서 도입된 개념으로, 객체의 데이터를 다른 객체로 '이동'하는 기능을 말합니다. 이는 객체 간의 깊은 복사(deep copy)를 피하고, 소유권을 이전하여 성능을 최적화합니다. 이동 의미론은 주로 이동 생성자(Move Constructor)와 이동 할당 연산자(Move Assignment Operator)를 통해 구현됩니다.

이동 생성자와 이동 할당 연산자는 오른값 참조를 사용하여 임시 객체의 리소스(예: 메모리)를 받아, 이 리소스를 새 객체에 '이동'합니다. 이 과정에서 원본 객체는 더 이상 해당 리소스에 대한 소유권을 갖지 않게 됩니다.

#include <iostream>
#include <vector>

class Moveable {
    std::vector<int> data;

public:
    // 이동 생성자
    Moveable(Moveable&& other) : data(std::move(other.data)) {
        std::cout << "Move Constructor called" << std::endl;
    }

    // 이동 할당 연산자
    Moveable& operator=(Moveable&& other) {
        if (this != &other) {
            data = std::move(other.data);
            std::cout << "Move Assignment Operator called" << std::endl;
        }
        return *this;
    }
};

int main() {
    Moveable a;
    Moveable b = std::move(a); // 이동 생성자 호출
    Moveable c;
    c = std::move(b); // 이동 할당 연산자 호출

    return 0;
}

이 코드에서 `Moveable` 클래스는 이동 생성자와 이동 할당 연산자를 정의합니다. `std::move` 함수를 사용하여 `other` 객체의 `data` 멤버의 소유권을 새로운 객체로 이동시킵니다. `main` 함수에서는 이러한 이동 의미론을 실제로 사용하는 예를 보여줍니다.

---

🗣️ 포인터가 무엇인가요?

• 포인터는 메모리의 주소를 저장하는 변수입니다. 포인터를 통해 해당 주소에 저장된 값을 읽거나 수정할 수 있습니다.
• 포인터는 다양한 데이터 타입을 가리킬 수 있으며, 다른 변수나 배열의 주소를 저장할 수 있습니다.
• 포인터의 크기는 고정되어 있으며, 특정 타입에 상관없이 일반적으로 시스템 아키텍처에 따라 크기가 결정됩니다 (32비트 시스템에서는 4바이트, 64비트 시스템에서는 8바이트).

---

🗣️ 포인터와 배열의 차이점이 무엇인가요?

 

배열의 이름은 배열의 첫 번째 요소를 가리키는 포인터로 사용될 수 있지만, 배열 자체는 포인터가 아니며 크기가 고정되어 있습니다. 또한 배열은 변수 선언과 함께 자신의 데이터를 저장할 공간을 배열의 크기만큼 연속적인 공간을 가집니다. 포인터는 자신이 데이터를 저장할 공간을 갖지 않고 저장할 공간이 있는 위치를 저장하는 메모리 번지를 저장합니다.

배열은 포인터 상수여서 다른 번지를 가리킬 수 없고, 포인터는 변수이므로 대입이 가능합니다. 또한 포인터 변수는 증감 연산자가 사용가능하지만, 배열은 상수이므로 사용할 수 없습니다.

---

🗣️ 상등성, 동등성이 뭔가요?

 

상등성(Identity) 과 동등성(Equality) 은 객체를 비교하는 두 가지 다른 개념입니다.

1. 상등성 (Identity): 상등성은 두 객체가 메모리 상에서 정확히 같은 위치에 있는지, 즉 두 객체가 완전히 동일한 객체인지를 나타냅니다. 상등성 비교는 주로 포인터나 참조를 통해 이루어집니다.

2. 동등성 (Equality): 동등성은 두 객체의 내용이나 상태가 동일한지를 나타냅니다. 이는 객체의 실제 값 또는 상태를 비교하는 것으로, 두 객체가 서로 다른 메모리 위치에 있더라도 내용이 같으면 동등하다고 할 수 있습니다.

#include <iostream>

class Point {
public:
    int x, y;

    Point(int x, int y) : x(x), y(y) {}

    // 동등성을 위한 연산자 오버로딩
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
};

int main() {
    Point a(1, 2);
    Point b(1, 2);
    Point& c = a;

    // 동등성 비교
    if (a == b) std::cout << "a and b are equal" << std::endl;
    else std::cout << "a and b are not equal" << std::endl;

    // 상등성 비교
    if (&a == &c) std::cout << "a and c are identical" << std::endl;
    else std::cout << "a and c are not identical" << std::endl;

    return 0;
}

이 코드에서 `Point` 클래스는 동등성 비교를 위해 `==` 연산자를 오버로드합니다. `a`와 `b`는 내용이 같지만 서로 다른 객체이므로 동등하지만 상등하지 않습니다. 반면, `a`와 `c`는 상등합니다 (같은 메모리 주소를 가리키고 있음).

---

🗣️ 오버로딩, 오버라이딩의 차이점이 무엇인가요?

 

오버로딩은 함수 이름은 같으나 함수의 매개변수, 타입을 다르게 사용하는 것입니다. 

오버라이딩이란 파생 클래스에서 재정의한 기본 클래스의 가상 함수의 호출을 보장받는 선언입니다.

함수의 반환 타입, 이름, 매개변수 타입과 개수까지 모두 같아야 합니다.

 

https://nextcoder.tistory.com/39

---

🗣️ C++ 생성자에 대해 아는대로 설명해줄래요?

 

C++에서 생성자(Constructor)는 클래스의 객체가 생성될 때 자동으로 호출되는 특별한 멤버 함수입니다. 생성자의 주요 목적은 객체를 초기화하는 것이며, 생성자의 이름은 클래스의 이름과 동일합니다. 생성자는 반환 타입을 가지지 않으며, 오버로드(즉, 여러 버전을 가질 수)가 가능합니다. 생성자의 주요 종류는 다음과 같습니다:

1. 디폴트 생성자 (Default Constructor): 아무런 인자도 받지 않는 생성자입니다. 사용자가 명시적으로 디폴트 생성자를 정의하지 않으면, 컴파일러는 자동으로 디폴트 생성자를 생성할 수 있습니다.
2. 파라미터가 있는 생성자 (Parameterized Constructor): 하나 이상의 매개변수를 가지고 객체의 초기 상태를 설정하는 데 사용됩니다.
3. 복사 생성자 (Copy Constructor): 다른 객체의 복사본을 만드는 데 사용됩니다. 비상수 왼값 참조(Type&)를 매개변수로 사용합니다.
4. 이동 생성자 (Move Constructor): C++11에서 도입되어 객체의 리소스를 다른 객체로 '이동'하는 데 사용됩니다.

class Rectangle {
    int width, height;

public:
    // 디폴트 생성자
    Rectangle() : width(0), height(0) {}

    // 파라미터가 있는 생성자
    Rectangle(int w, int h) : width(w), height(h) {}

    // 복사 생성자
    Rectangle(const Rectangle& other) : width(other.width), height(other.height) {}

    int area() { return width * height; }
};

int main() {
    Rectangle rect1;                // 디폴트 생성자 호출
    Rectangle rect2(3, 4);          // 파라미터가 있는 생성자 호출
    Rectangle rect3 = rect2;        // 복사 생성자 호출

    return 0;
}

 

---

🗣️ C++ 클래스에서 암시적으로 생성되는 함수가 있나요? 

 

1. 디폴트 생성자 (Default Constructor): 객체가 생성될 때 아무런 인자도 전달받지 않을 때 호출됩니다.
2. 복사 생성자 (Copy Constructor): 객체가 다른 객체의 복사본으로 생성될 때 호출됩니다.
3. 복사 할당 연산자 (Copy Assignment Operator): 객체에 다른 객체의 내용을 복사할 때 사용됩니다.
4. 이동 생성자 (Move Constructor): C++11 이후에 추가된 기능으로, 임시 객체의 리소스를 이전할 때 사용됩니다.
5. 이동 할당 연산자 (Move Assignment Operator): C++11 이후에 추가된 기능으로, 임시 객체의 리소스를 다른 객체에 이전할 때 사용됩니다.
6. 소멸자 (Destructor): 객체의 수명이 끝날 때 호출되어 리소스를 정리합니다.

class Example {
    int value;
public:
    Example() : value(0) {} // 디폴트 생성자 명시적 정의
    // 복사 생성자, 복사 할당 연산자, 소멸자는 암시적으로 생성됨
};

int main() {
    Example obj1;          // 디폴트 생성자 호출
    Example obj2 = obj1;   // 복사 생성자 호출
    Example obj3;
    obj3 = obj1;           // 복사 할당 연산자 호출
    // obj1, obj2, obj3 소멸 시 소멸자 호출
    return 0;
}

이 코드에서 `Example` 클래스는 디폴트 생성자만 명시적으로 정의합니다. 복사 생성자, 복사 할당 연산자, 소멸자는 컴파일러에 의해 암시적으로 생성됩니다. 객체 `obj1`은 디폴트 생성자를 사용해 생성되고, `obj2`는 복사 생성자를 사용해 `obj1`의 복사본으로 생성됩니다. `obj3`은 복사 할당 연산자를 통해 `obj1`의 내용을 받습니다. 각 객체의 수명이 끝날 때 소멸자가 호출됩니다.

---

🗣️ Class, Struct 의 차이는 무엇인가요?

 

클래스와 구조체는 멤버 함수, 생성자, 그리고 소멸자를 가질 수 있고 상속을 사용할 수 있다는 공통점이 있지만,

클래스의 기본 접근 지정자는 정보 은닉을 위해 `private`이며, 구조체의 기본 접근 지정자는 `public`이라는 차이점이 있습니다.

또한 클래스는 대체로 데이터와 메서드를 캡슐화하는 데 사용하며 구조체는 주로 관련된 데이터를 하나의 단위로 묶어 저장하는 데 사용됩니다. 

---

🗣️ C++의 템플릿이란 무엇인가요?

 

C++의 템플릿은 타입에 독립적인 코드를 작성할 수 있게 해주는 기능입니다. 즉, 함수나 클래스를 작성할 때 특정 타입을 고정하지 않고, 컴파일 시점에 필요한 타입으로 지정할 수 있습니다. 이를 통해 동일한 로직을 다양한 데이터 타입에 재사용할 수 있으며, 코드 중복을 줄이고 유지보수를 용이하게 합니다.

template <typename T>
T getMax(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    // int 타입에 대한 getMax 함수 사용
    int intMax = getMax(3, 7);
    std::cout << "Max of 3 and 7 is " << intMax << std::endl;

    // double 타입에 대한 getMax 함수 사용
    double doubleMax = getMax(3.5, 2.5);
    std::cout << "Max of 3.5 and 2.5 is " << doubleMax << std::endl;

    return 0;
}

이 코드에서 `getMax` 함수는 템플릿을 사용하여 정의되었습니다. `typename T`는 어떠한 타입도 될 수 있음을 나타냅니다. `main` 함수에서는 `getMax`를 `int`와 `double` 타입에 대해 각각 호출하여, 템플릿 함수가 다양한 타입에 대해 재사용될 수 있음을 보여줍니다.

---

🗣️ 참조 리턴이란 무엇인가요?

 

참조 반환(Reference Return)은 C++에서 함수가 참조(`&`) 형식으로 결과를 반환하는 것을 의미합니다. 이 방식을 사용하면 함수는 값이 아닌 메모리 주소를 반환합니다. 이는 값의 복사가 아닌 원래 변수나 객체에 대한 직접적인 접근을 제공하므로, 메모리 사용 효율성을 높이고 성능을 개선할 수 있습니다. 그러나 참조 반환은 신중하게 사용해야 하며, 특히 지역 변수의 참조를 반환할 때는 주의가 필요합니다.

간단한 예시로, 아래의 코드는 `int` 타입의 참조를 반환하는 간단한 함수를 보여줍니다:

int& getMax(int& a, int& b) {
    return (a > b) ? a : b;
}

int main() {
    int x = 10;
    int y = 20;

    // getMax 함수를 호출하고 반환된 참조를 통해 값을 수정
    getMax(x, y) = 30;

    // 이제 x는 10, y는 30
    std::cout << "x: " << x << ", y: " << y << std::endl;

    return 0;
}

이 코드에서 `getMax` 함수는 `a`와 `b` 중 큰 값의 참조를 반환합니다. 그리고 `main` 함수에서 `getMax(x, y)`를 통해 반환된 참조를 사용하여 `y`의 값을 30으로 변경합니다. 이 예시는 참조 반환을 통해 원본 변수에 직접 접근하고 수정하는 방법을 보여줍니다.

---

🗣️ 해시테이블과 std map 에 대해 설명해주실래요?

 

(hash table = `unordered_map`)

 

해시테이블의 값은 키에 대한 해시 함수를 호출하여 저장합니다. 값은 정렬된 순서로 보관되지 않으며 값을 저장한 인덱스를 찾기 위해 키를 사용합니다. 삽입 및 검색은 `O(1)` 시간에 수행됩니다. 또한, 잠재적 충돌을 고려하여 구현해야 합니다. 보통은 충돌되는 값을 서로 체이닝하여 이 문제를 해결하는데, 특정 키에 대응되는 인덱스 위치에 모든 값을 연결리스트로 묶는 방법으로 해결합니다. 

 

단점은 이진탐색보다 훨씬 빠른 성능을 자랑하지만, 그 성능을 위해 많은  메모리를 요구한다는 점입니다.(테이블생성) https://song-ift.tistory.com/m/55

 

C++ standard library 의 Map 은 키를 기준으로 만든 red-black tree에 키와 값 쌍으로 보관합니다. 충돌을 처리할 필요가 없으며 트리의 균형이 유지되므로 삽입, 검색 연산의 시간은 `O(logN)` 으로 보장됩니다.

---

🗣️ 파이썬과 C++의 차이점 에 대해 설명해주실래요?

 

파이썬과 C++ 모두 객체지향 언어입니다. 파이썬은 인터프리터 언어로 소스 코드를 한줄 한줄씩 읽어 명령을 처리하므로 컴파일러 언어보다 속도가 느립니다. C++은 컴파일러 언어이며 코드를 한 번에 어셈블리 언어로 번역 후 한 번에 실행하는 언어입니다.

---

🗣️ C++ 빌드 과정에 대해 설명해 주세요.

 

소스 코드 작성, 전처리, 컴파일, 어셈블, 링킹, 실행 순으로 수행됩니다. 먼저, 사용자가 작성한 소스코드의 `#`으로 시작하는 전처리기 구문을 처리합니다. 그 다음 컴파일 단계에서 고수준의 언어를 어셈블리 언어로 번역하는 작업을 합니다. 어셈블 단계에서는 어셈블리 파일을 오브젝트 파일로 만들고 오브젝트 파일을 합치고, 링킹 단계에서는 라이브러리와 연결해 주고 실행 가능한 파일을 생성해줍니다.

---

🗣️ dynamic linking, static linking 의 차이점에 대해 설명해 주세요.

 

linking 이란 여러 개의 코드와 데이터(라이브러리)를 연결해 실행할 수 있는 하나의 파일로 만드는 작업을 말합니다.

 

static linking 은 실행파일을 생성할 때 라이브러리를 같이 포함시켜서 `.exe` 파일로 만드는 것을 말합니다. 만약 여러 프로그램에서 라이브러리 A를 사용할 때, 해당 프로그램의 오브젝트 파일 각각에 라이브러리 A의 정보가 포함됩니다. 중복이 발생하여 메모리 공간을 낭비하게 됩니다. 또한, 라이브러리에 변경이 생기면 변경 적용을 위해 다시 컴파일하여 링킹을 해야합니다. 모든 코드는 하나의 실행 모듈에 담기기 때문에 불일치가 발생하지 않고 동적 링킹 방식보다 빠르다는 장점이 있습니다.

 

dynamic linking은 오브젝트 파일을 만들 때, 프로그램에서 사용하는 모든 라이브러리들을 복사하지 않고 해당 주소만 가지고 있다가 런타임에 실행 파일과 라이브러리가 메모리에 적재될 때 해당 라이브러리의 주소로 가져오는 방식입니다. 이 방식을 사용하면 여러 프로그램에서 라이브러리 A를 사용한다 해도, A의 주소 하나만 가지고 있으면 됩니다. 따라서 오브젝트 파일의 크기가 작아 메모리 공간을 아낄 수 있게 됩니다. 매번 주소로 가야하므로 오버헤드가 발생하여 정적 링킹보다 느립니다. 또한, 불일치 문제가 발생할 수 있습니다. 왜냐하면 프로그램에서 A를 동적 링킹 방식으로 할 때, A가 제거될 경우 더 이상 참조할 함수가 없게 되기 때문입니다.

---

Reference

 

https://velog.io/@jacod2/C-%EB%A9%B4%EC%A0%91-%ED%82%A4%EC%9B%8C%EB%93%9C

https://makefortune2.tistory.com/242

https://wecandev.tistory.com/96

https://velog.io/@mardi2020/C-%EB%A9%B4%EC%A0%91-%EC%A7%88%EB%AC%B8-%EC%A0%95%EB%A6%AC