C++ 포인터, 동적 할당, 참조 변수에 대해 학습하기

포인터

 

- 이미 존재하는 다른 변수를 가리키는(point) 역할을 하는 변수

- 다른 변수에 대한 주소를 값으로서 가짐

 

 

 

 

- 포인터 변수는 주소를 저장함

 

 

 

T 타입에 대한 포인터 : T*

 

 

포인터 변수 값의 대입

 

 

*포인터 변수 : 원 변수 값의 조회 및 변경

 

 

 

포인터 변수의 정의와 사용 예 

 

 

 

 

 

C++의 동적 할당 : new와 delete

 

 

메모리 할당 : new

- T* = new T ;

- T* = new T[size] ;

 

 

메모리 해제 : delete

- delete p ;

- delete [] p ;

 

 

 

 

포인터 관련 오류 최소화하기

 

: 일반적으로 포인터는 주로 두 가지 용도로 사용한다

 (1) 개체 참조   - 문제 : 해제된 메모리 참조, double free

 (2) 동적 메모리를 관리   -문제 : 메모리 누수 발생

=> 포인터는 누군가가 개체를 참조하고 있는지, 더 이상 필요하지 않아 메모리를 해제해야 하는지 알 수 없음

 

 

<오류 최소화하는 방법>

- 표준 라이브러리(std::vector, std::string 등)나 검증된 라이브러리를 사용하기

- 클래스를 정의하고 동적 메모리 할당 및 해제를 관리하기 (RAII 원칙) : RAII(Resource Acquisition Is Initialization) 원칙은 객체의 생명주기와 자원의 관리를 연결하는 패턴으로, 스마트 포인터와 같은 C++의 자원 관리 도구는 이 원칙을 준수하여 자원을 자동으로 관리하고 메모리 누수나 기타 자원 관련 오류를 방지한다.

- 스마트 포인터(Smart Pointer)를 사용하기 : 코드에서 메모리 관리의 복잡성을 줄이고, 안전하고 효율적인 코드 작성을 할 수 있다.

 

 

 

<표준 라이브러리>

 

1. std::vector

동적 배열을 제공하며, 요소의 추가, 삭제, 접근 등이 효율적으로 처리됨

메모리 관리를 자동으로 처리하므로 동적 배열을 직접 관리할 필요가 없다.

#include <vector>

void example() {
    std::vector<int> v;  // int 타입의 동적 배열
    v.push_back(1);     // 배열에 요소 추가
    v.push_back(2);
    // 메모리 관리 자동 처리
}

 

2. std::string

동적 문자열을 제공하며, 메모리 관리를 자동으로 처리. 문자열 작업을 안전하게 수행할 수 있다.

#include <string>

void example() {
    std::string str = "Hello, World!";
    // 문자열 작업
    std::cout << str << std::endl;
}

 

3. std::map, std::unordered_map

키-값 쌍을 저장하는 데이터 구조를 제공

std::map은 정렬된 데이터 구조를 제공

std::unordered_map은 해시 기반 데이터 구조를 제공

 

 

 

<주요 검증된 라이브러리>

 

Boost: 다양한 기능을 제공하는 C++ 라이브러리 모음으로, 표준 라이브러리에서 제공하지 않는 기능을 추가한다. 예를 들어, 스마트 포인터, 정규 표현식, 파일 시스템 등이 포함

Eigen: C++로 작성된 고성능 선형 대수 라이브러리로, 행렬 연산, 벡터 연산 등 다양한 기능을 제공

spdlog: 고성능 C++ 로깅 라이브러리로, 다양한 로그 레벨과 포맷팅 옵션을 제공

 

 

 

 

스마트 포인터의 유형 : unique_ptr, shared_ptr

 

- unique_ptr : 참조한 데이터의 고유 소유권을 나타내며 포인터 사용이 만료되면 메모리가 자동으로 해제됨

  인스턴스는 하나만 존재하며, 다른 std::unique_ptr로 복사할 수 없다. 하지만 이동(semove)할 수는 있다.

  메모리 관리가 자동으로 이루어지고, 이동만 가능하기 때문에 소유권이 명확하게 관리됨

  동적으로 할당하지 않음(할당 금지)

#include <memory>

void example() {
    std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
    // std::unique_ptr<int> ptr2 = ptr1;  // 컴파일 오류: 복사 불가능
    std::unique_ptr<int> ptr2 = std::move(ptr1);  // 이동 가능
}  // ptr2가 파괴되면서 메모리 해제

 

 

- shared_ptr : 여러 곳에서 공통으로 사용하는 메모리를 관리하며, 더 이상 데이터를 참조하지 않는 즉시 메모리를 해제함

  여러 인스턴스가 동일한 메모리를 공유할 수 있으며, 마지막 std::shared_ptr가 파괴되면 메모리가 해제됨

  객체를 여러 곳에서 공유할 수 있어 복잡한 객체 공유가 필요한 경우 유용하다

  자동으로 참조 카운트를 관리하여 메모리 해제를 자동으로 수행함

  동적으로 할당함

#include <memory>

void example() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(20);
    std::shared_ptr<int> ptr2 = ptr1;  // ptr1과 ptr2가 같은 메모리를 공유
}  // ptr1과 ptr2가 파괴되면서 메모리 해제

 

 

• std::unique_ptr을 사용해야 하는 경우:
  • 단일 소유권이 필요하고, 소유권이 이동하는 경우
  • 성능이 중요한 상황에서 불필요한 참조 카운트 관리가 필요 없는 경우
• std::shared_ptr을 사용해야 하는 경우:
  • 여러 객체가 동일한 자원을 공유할 필요가 있는 경우
  • 객체의 소유권이 명확하지 않고, 여러 소유자가 필요한 경우

 

 

 

 

이동 시멘틱스(Move Semantics)

이동 시멘틱스는 C++11에서 도입된 개념으로, 자원을 효율적으로 이동시키는 방법을 제공한다. 이동 시멘틱스는 객체를 복사하는 대신 자원을 "이동"하여 성능을 향상시키고, 불필요한 복사를 방지한다. 이는 특히 자원이 동적 할당된 경우 유용

 

 

std::unique_ptr에서의 이동

- 이동 생성자: 기존 std::unique_ptr 객체에서 새 std::unique_ptr 객체로 소유권을 이동할 때 사용

- 이동 대입 연산자: 기존 std::unique_ptr 객체에 다른 std::unique_ptr 객체의 소유권을 이동할 때 사용

#include <iostream>
#include <memory>

class Example {
public:
    Example() { std::cout << "Constructor\n"; }
    ~Example() { std::cout << "Destructor\n"; }
    Example(const Example&) = delete;              // 복사 생성자 삭제
    Example& operator=(const Example&) = delete;   // 복사 대입 연산자 삭제
    Example(Example&&) noexcept { std::cout << "Move Constructor\n"; } // 이동 생성자
    Example& operator=(Example&&) noexcept {       // 이동 대입 연산자
        std::cout << "Move Assignment\n";
        return *this;
    }
};

void example() {
    std::unique_ptr<Example> p1 = std::make_unique<Example>();  // 생성 및 소유권 획득
    std::unique_ptr<Example> p2 = std::move(p1);                // p1의 소유권을 p2로 이동

    if (!p1) {
        std::cout << "p1 is now empty\n";
    }
    if (p2) {
        std::cout << "p2 owns the Example object\n";
    }
}

int main() {
    example();
    return 0;
}

std::unique_ptr p2 = std::move(p1);

- std::move를 사용하여 p1의 소유권을 p2로 이동. 이동 후 p1은 nullptr이 된다.

 

 

std::shared_ptr의 이동

- 이동 생성자: std::shared_ptr의 이동 생성자는 소유권을 새 std::shared_ptr로 이전하며, 원래 포인터는 비워진다

이동 대입 연산자: std::shared_ptr의 이동 대입 연산자는 소유권을 기존의 std::shared_ptr에 이전하며, 이동된 std::shared_ptr은 비워진다.

#include <iostream>
#include <memory>

void example() {
    // 소유권이 sp1에 있는 객체 생성
    std::shared_ptr<int> sp1 = std::make_shared<int>(100);
    
    // sp1의 소유권을 sp2로 이동
    std::shared_ptr<int> sp2 = std::move(sp1);

    if (!sp1) {
        std::cout << "sp1 is now empty\n";  // sp1은 이동 후 비어 있음
    }
    if (sp2) {
        std::cout << "sp2 owns the object with value: " << *sp2 << std::endl;
    }
}

int main() {
    example();
    return 0;
}

 

 

- std::make_shared(100)으로 생성된 std::shared_ptr sp1은 100이라는 값을 가진 int 객체를 소유함

- std::move(sp1)을 통해 sp1의 소유권이 sp2로 이동. 이동 후 sp1은 nullptr 상태가 되며, sp2가 객체를 소유하게 된다.

 

 

 

주의점 : 포인터는 인자로 전달하지 말자 !

C++에서 함수의 인자로 포인터를 전달하는 경우, 여러 가지 문제를 일으킬 수 있다. 예를 들어, 포인터는 null일 수 있고, 잘못된 메모리 위치를 참조할 수 있으며, 메모리 누수나 이중 해제 문제를 일으킬 수 있다. 이러한 문제를 피하기 위해, 웬만하면 포인터 대신 참조나 스마트 포인터를 사용하는 것이 좋다.

 

 

함수의 인자로 포인터를 전달하는 경우, 문제 발생!

#include <iostream>

// 포인터를 인자로 받는 함수
void process(int* ptr) {
    if (ptr) {  // 포인터가 null이 아닌지 체크
        *ptr += 10;  // 포인터가 가리키는 메모리 위치의 값을 10 증가
    } else {
        std::cout << "Received null pointer.\n";  // 포인터가 null인 경우 오류가 발생하므로 오류 메세지 출력!!!!
    }
}

int main() {
    int value = 5;  // 정수 변수 value를 선언하고 초기화
    process(&value);  // value의 주소를 포인터로 넘김
    std::cout << "Value after process: " << value << std::endl;  // 변경된 value 출력
    return 0;
}

 

 

참조를 사용하기

- 포인터 대신 참조를 사용하면 함수가 직접 객체를 조작할 수 있으며, null 값 문제를 피할 수 있다.

#include <iostream>

void process(int& value) {
    value += 10;
}

int main() {
    int value = 5;
    process(value);
    std::cout << "Value after process: " << value << std::endl;
    return 0;
}

 

 

스마트 포인터 사용하기

#include <iostream>
#include <memory>

void process(std::shared_ptr<int> value) {
    if (value) {
        *value += 10;
    } else {
        std::cout << "Received null shared_ptr.\n";
    }
}

int main() {
    auto value = std::make_shared<int>(5);
    process(value);
    std::cout << "Value after process: " << *value << std::endl;
    return 0;
}

 

 

 

 

 

포인터와 상수

 

: 유연하고 복잡한 데이터 구조를 처리할 수 있으며, 저수준 메모리 조작이 필요한 경우에 유용하다.

 

• 동적 메모리 관리: 동적 배열이나 객체의 주소를 처리해야 할 때 포인터를 사용
• 구조체와 클래스: 포인터를 통해 복잡한 데이터 구조를 처리할 때 필요할 수 있다.
• 저수준 메모리 조작: 포인터는 메모리 주소를 직접 다룰 수 있으므로, 저수준 메모리 조작이 필요한 경우 유용

 

그러나 포인터는 +, ++, -- 등의 연산자를 이용해 임의의 메모리를 가리킬 경우 문제를 유발하므로 참조 변수를 더 많이 사용함

 

 

 

ex)

 

 

 

상수포인터

 

- 상수 포인터는 포인터가 가리키는 데이터가 상수로 취급되어 해당 데이터를 변경할 수 없도록 하는 포인터

const int* ptr;

 

 

- 이 개념은 프로그램의 안정성을 높이고, 의도하지 않은 데이터 변경을 방지하는 데 도움을 준다.

 

 

포인터가 가리키는 값을 변경하지 못하는 포인터

 

상수에 대한 포인터의 활용 예

 

 

 

 

상수에 대한 포인터

 

- 상수 자체를 가리키는 포인터는 포인터가 가리키는 주소를 변경할 수 없으며, 포인터의 값(주소)은 초기화 시 설정된 후 변경할 수 없다.

- 포인터 자체는 변경할 수 없지만, 포인터가 가리키는 데이터는 변경할 수 있다.

int* const ptr;

 

 

 

 

상수에 대한 상수 포인터

 

- 포인터가 가리키는 데이터와 포인터 자체 모두 변경할 수 없다.

- 포인터가 가리키는 값도 변경할 수 없고, 포인터 자체도 변경할 수 없다

const int* const ptr;

 

 

 

 

 

참조(reference) 변수

 

: 참조 변수는 코드의 안전성과 가독성을 높이기 때문에, 데이터의 불변성을 보장하고자 할 때 일반적으로 더 많이 사용됨

  참조 변수는 특정 변수에 대한 별칭으로 변수의 원본 값을 직접 참조할 수 있도록 한다 (다른 변수를 가리키는 역할)

  참조는 반드시 초기화되어야 하며, 참조가 설정된 후에는 다른 변수를 참조할 수 없다.

 

 

 

 

• 간단한 데이터 접근: 데이터의 불변성을 보장하고, 포인터 연산의 복잡성을 피하고 싶을 때 참조 변수를 사용
• 안전성: 참조는 null이 될 수 없으며, 코드가 더 안전하고 명확
• 가독성: 참조를 사용하면 코드의 의도가 더 명확
• 간결함: 참조는 포인터보다 문법이 간단하고, null 체크나 메모리 주소 연산이 필요없

 

 

참조 변수 T&

: T타입 변수에 대한 참조

- 변수 T에 대한 별칭으로, 변수의 원본 값을 직접 참조한다.

- 참조는 선언 시 초기화해야 하며, 이후에는 참조 대상을 변경할 수 없다.

 

 

 

상수 포인터보다 더 잘 사용되는 상수 참조 !

 

상수 참조는 참조된 데이터의 값을 변경할 수 없도록 하는 참조이다. 함수 인자로 데이터 변경을 방지하고 싶을 때 유용

#include <iostream>

// 상수 참조를 인자로 받아 값을 읽기만 하는 함수
void printValue(const int& ref) {
    std::cout << "Value: " << ref << std::endl;
    // ref = 10; // 오류: 상수 참조로 인해 값 변경 불가
}

int main() {
    int value = 5;
    printValue(value);  // 상수 참조로 value를 전달
    return 0;
}

 

상수 참조 const T&: 데이터를 변경할 수 없도록 하여, 데이터 읽기 전용으로 사용할 때 유용

• void printValue(const int& ref)는 상수 참조를 사용하여 ref가 참조하는 값을 읽기만 함 ref를 통해 값을 변경할 수 없다
• 상수 참조를 사용하면 함수가 인자로 받은 데이터를 안전하게 읽을 수 있으며, 데이터의 불변성을 보장할 수 있음