[2026] C++ new vs malloc | 생성자·타입 안전성·예외 처리 완벽 비교

· 30분 읽기 · 수정 초급 비교
[2026] C++ new vs malloc | 생성자·타입 안전성·예외 처리 완벽 비교

이 글의 핵심

C++ new vs malloc 차이점. 생성자·소멸자, 타입 안전성, 실패 시 예외 vs nullptr. 성능은 거의 비슷하지만 C++ 객체에는 new·delete를 쓰는 것이 맞는 이유와 실전 선택을 정리합니다.

들어가며

C++는 new와 malloc 두 가지 메모리 할당 방법을 제공합니다. malloc은 C에서 물려받은 함수이고, new는 C++ 전용 연산자입니다. 비유로 말씀드리면, malloc은 빈 방만 열어 주는 것이고, new는 가구를 조립해 놓은 방을 넘겨주는 것에 가깝습니다. C++ 객체에는 생성자·소멸자가 있으므로 “방만”이 아니라 초기화까지 맞추려면 new/delete 쪽이 맞습니다.

이 글을 읽으면

  • new와 malloc의 7가지 차이점을 이해합니다
  • 생성자 호출, 타입 안전성, 예외 처리의 차이를 파악합니다
  • 성능 비교와 실무 선택 기준을 익힙니다
  • 혼용 시 주의사항과 C 라이브러리 연동 패턴을 확인합니다

실무에서 마주한 현실

개발을 배울 때는 모든 게 깔끔하고 이론적입니다. 하지만 실무는 다릅니다. 레거시 코드와 씨름하고, 급한 일정에 쫓기고, 예상치 못한 버그와 마주합니다. 이 글에서 다루는 내용도 처음엔 이론으로 배웠지만, 실제 프로젝트에 적용하면서 “아, 이래서 이렇게 설계하는구나” 하고 깨달은 것들입니다. 특히 기억에 남는 건 첫 프로젝트에서 겪은 시행착오입니다. 책에서 배운 대로 했는데 왜 안 되는지 몰라 며칠을 헤맸죠. 결국 선배 개발자의 코드 리뷰를 통해 문제를 발견했고, 그 과정에서 많은 걸 배웠습니다. 이 글에서는 이론뿐 아니라 실전에서 마주칠 수 있는 함정들과 해결 방법을 함께 다루겠습니다.

목차

  1. new vs malloc 7가지 차이
  2. 실전 구현
  3. 고급 활용
  4. 성능 비교
  5. 실무 사례
  6. 트러블슈팅
  7. 마무리

new vs malloc 7가지 차이

비교표

항목newmalloc
언어C++ 연산자C 함수
생성자 호출✅ 호출함❌ 호출 안 함
타입 안전성✅ 안전 (캐스팅 불필요)❌ 불안전 (캐스팅 필요)
크기 계산자동수동 (sizeof)
실패 시예외 (bad_alloc)nullptr 반환
해제deletefree
배열 할당new[]malloc + 크기
오버로드가능 (operator new)불가능

실전 구현

1) 기본 타입 할당

malloc

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <cstdlib>
#include <iostream>
int main() {
    // malloc: 캐스팅 필요
    int* ptr = (int*)malloc(sizeof(int));
    
    if (ptr == nullptr) {  // nullptr 체크 필요
        std::cerr << "할당 실패" << std::endl;
        return 1;
    }
    
    *ptr = 42;
    std::cout << *ptr << std::endl;
    
    free(ptr);
    
    return 0;
}

new

아래 코드는 cpp를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iostream>
int main() {
    // new: 캐스팅 불필요, 초기화 동시에
    int* ptr = new int(42);
    
    std::cout << *ptr << std::endl;
    
    delete ptr;
    
    return 0;
}

2) 클래스 할당

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iostream>
class MyClass {
private:
    int x_;
    
public:
    MyClass() : x_(0) {
        std::cout << "생성자 호출" << std::endl;
    }
    
    ~MyClass() {
        std::cout << "소멸자 호출" << std::endl;
    }
    
    void setValue(int x) { x_ = x; }
    int getValue() const { return x_; }
};
int main() {
    // ❌ malloc: 생성자 호출 안 됨
    MyClass* obj1 = (MyClass*)malloc(sizeof(MyClass));
    // "생성자 호출" 출력 안 됨
    // obj1->x_는 쓰레기 값
    free(obj1);  // 소멸자 호출 안 됨
    
    // ✅ new: 생성자 호출
    MyClass* obj2 = new MyClass();
    // "생성자 호출" 출력
    obj2->setValue(42);
    std::cout << obj2->getValue() << std::endl;
    delete obj2;  // "소멸자 호출" 출력
    
    return 0;
}

중요: 클래스 객체는 반드시 new를 사용해야 합니다.

3) 배열 할당

malloc

아래 코드는 cpp를 사용한 구현 예제입니다. 반복문으로 데이터를 처리합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// malloc: 크기 수동 계산
int* arr1 = (int*)malloc(10 * sizeof(int));
for (int i = 0; i < 10; ++i) {
    arr1[i] = i;
}
free(arr1);

new

아래 코드는 cpp를 사용한 구현 예제입니다. 반복문으로 데이터를 처리합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// new: 크기 자동 계산
int* arr2 = new int[10];
for (int i = 0; i < 10; ++i) {
    arr2[i] = i;
}
delete[] arr2;  // 배열은 delete[]

4) 예외 처리

malloc: nullptr 반환

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <cstdlib>
#include <iostream>
int main() {
    int* ptr = (int*)malloc(1000000000000);  // 1TB 할당 (실패)
    
    if (ptr == nullptr) {  // 수동 체크 필요
        std::cerr << "할당 실패" << std::endl;
        return 1;
    }
    
    free(ptr);
    
    return 0;
}

new: 예외 던짐

아래 코드는 cpp를 사용한 구현 예제입니다. 필요한 모듈을 import하고, 비동기 처리를 통해 효율적으로 작업을 수행합니다, 에러 처리를 통해 안정성을 확보합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iostream>
int main() {
    try {
        int* ptr = new int[1000000000000];  // 1TB 할당 (실패)
        delete[] ptr;
    } catch (const std::bad_alloc& e) {
        std::cerr << "할당 실패: " << e.what() << std::endl;
    }
    
    return 0;
}

new (std::nothrow)

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 에러 처리를 통해 안정성을 확보합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <new>
#include <iostream>
int main() {
    int* ptr = new (std::nothrow) int[1000000000000];
    
    if (ptr == nullptr) {
        std::cerr << "할당 실패" << std::endl;
        return 1;
    }
    
    delete[] ptr;
    
    return 0;
}

고급 활용

1) placement new

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <new>
#include <iostream>
int main() {
    // 메모리 할당
    char buffer[sizeof(MyClass)];
    
    // placement new: 기존 메모리에 객체 생성
    MyClass* obj = new (buffer) MyClass();
    
    obj->setValue(42);
    std::cout << obj->getValue() << std::endl;
    
    // 소멸자 수동 호출
    obj->~MyClass();
    
    return 0;
}

2) 커스텀 operator new

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 에러 처리를 통해 안정성을 확보합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iostream>
#include <cstdlib>
void* operator new(size_t size) {
    std::cout << "커스텀 new: " << size << " bytes" << std::endl;
    void* ptr = malloc(size);
    if (!ptr) throw std::bad_alloc();
    return ptr;
}
void operator delete(void* ptr) noexcept {
    std::cout << "커스텀 delete" << std::endl;
    free(ptr);
}
int main() {
    int* ptr = new int(42);
    delete ptr;
    
    return 0;
}

3) C 라이브러리 래핑

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <memory>
#include <cstdlib>
extern "C" {
    char* c_function() {
        return (char*)malloc(100);
    }
}
std::unique_ptr<char, decltype(&free)> wrap_c_function() {
    char* ptr = c_function();
    return {ptr, free};  // 커스텀 삭제자
}
int main() {
    auto ptr = wrap_c_function();
    // 자동으로 free 호출
    
    return 0;
}

성능 비교

기본 타입 할당

테스트: 100만 번 할당/해제 다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <chrono>
#include <iostream>
void benchMalloc() {
    for (int i = 0; i < 1000000; ++i) {
        int* ptr = (int*)malloc(sizeof(int));
        *ptr = i;
        free(ptr);
    }
}
void benchNew() {
    for (int i = 0; i < 1000000; ++i) {
        int* ptr = new int(i);
        delete ptr;
    }
}
int main() {
    auto start1 = std::chrono::high_resolution_clock::now();
    benchMalloc();
    auto end1 = std::chrono::high_resolution_clock::now();
    auto time1 = std::chrono::duration_cast<std::chrono::milliseconds>(end1 - start1).count();
    
    auto start2 = std::chrono::high_resolution_clock::now();
    benchNew();
    auto end2 = std::chrono::high_resolution_clock::now();
    auto time2 = std::chrono::duration_cast<std::chrono::milliseconds>(end2 - start2).count();
    
    std::cout << "malloc/free: " << time1 << "ms" << std::endl;
    std::cout << "new/delete: " << time2 << "ms" << std::endl;
    
    return 0;
}

결과:

방법시간상대 속도
malloc/free850ms1.0x
new/delete860ms1.01x
결론: 성능 차이는 거의 없음

실무 사례

사례 1: 게임 엔진 - 객체 풀

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <vector>
#include <iostream>
class GameObject {
private:
    int id_;
    bool active_;
    
public:
    GameObject() : id_(0), active_(false) {
        std::cout << "GameObject 생성" << std::endl;
    }
    
    ~GameObject() {
        std::cout << "GameObject 소멸" << std::endl;
    }
    
    void activate(int id) {
        id_ = id;
        active_ = true;
    }
    
    void deactivate() {
        active_ = false;
    }
};
class ObjectPool {
private:
    std::vector<GameObject*> pool_;
    
public:
    ObjectPool(size_t size) {
        for (size_t i = 0; i < size; ++i) {
            pool_.push_back(new GameObject());  // new 사용
        }
    }
    
    ~ObjectPool() {
        for (auto* obj : pool_) {
            delete obj;  // 소멸자 호출
        }
    }
    
    GameObject* acquire() {
        if (pool_.empty()) return nullptr;
        auto* obj = pool_.back();
        pool_.pop_back();
        return obj;
    }
    
    void release(GameObject* obj) {
        obj->deactivate();
        pool_.push_back(obj);
    }
};
int main() {
    ObjectPool pool(10);
    
    auto* obj = pool.acquire();
    obj->activate(1);
    
    pool.release(obj);
    
    return 0;
}

사례 2: C 라이브러리 연동

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <memory>
#include <cstdlib>
#include <cstring>
extern "C" {
    struct CData {
        int id;
        char name[100];
    };
    
    CData* create_data(int id, const char* name) {
        CData* data = (CData*)malloc(sizeof(CData));
        data->id = id;
        strncpy(data->name, name, 99);
        data->name[99] = '\0';
        return data;
    }
    
    void destroy_data(CData* data) {
        free(data);
    }
}
std::unique_ptr<CData, decltype(&destroy_data)> wrap_data(int id, const char* name) {
    CData* data = create_data(id, name);
    return {data, destroy_data};
}
int main() {
    auto data = wrap_data(1, "test");
    std::cout << data->id << ", " << data->name << std::endl;
    // 자동으로 destroy_data 호출
    
    return 0;
}

사례 3: 메모리 풀 - placement new

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 에러 처리를 통해 안정성을 확보합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <new>
#include <vector>
#include <iostream>
class MemoryPool {
private:
    char* buffer_;
    size_t size_;
    size_t offset_;
    
public:
    MemoryPool(size_t size) : size_(size), offset_(0) {
        buffer_ = (char*)malloc(size);  // malloc으로 버퍼 할당
    }
    
    ~MemoryPool() {
        free(buffer_);
    }
    
    template<typename T, typename....Args>
    T* allocate(Args&&....args) {
        if (offset_ + sizeof(T) > size_) {
            throw std::bad_alloc();
        }
        
        void* ptr = buffer_ + offset_;
        offset_ += sizeof(T);
        
        return new (ptr) T(std::forward<Args>(args)...);  // placement new
    }
};
int main() {
    MemoryPool pool(1024);
    
    int* p1 = pool.allocate<int>(42);
    int* p2 = pool.allocate<int>(100);
    
    std::cout << *p1 << ", " << *p2 << std::endl;
    
    return 0;
}

트러블슈팅

문제 1: malloc-delete 혼용

증상: 크래시 또는 메모리 누수 아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// ❌ 미정의 동작
int* ptr1 = (int*)malloc(sizeof(int));
delete ptr1;  // ❌ malloc-delete 혼용
// ❌ 미정의 동작
int* ptr2 = new int(42);
free(ptr2);  // ❌ new-free 혼용
// ✅ 올바른 짝
int* ptr3 = (int*)malloc(sizeof(int));
free(ptr3);
int* ptr4 = new int(42);
delete ptr4;

문제 2: 생성자 호출 누락

증상: 멤버 변수가 쓰레기 값 다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

class MyClass {
private:
    int x_;
    
public:
    MyClass() : x_(0) {}
    int getValue() const { return x_; }
};
// ❌ malloc: 생성자 호출 안 됨
MyClass* obj = (MyClass*)malloc(sizeof(MyClass));
std::cout << obj->getValue() << std::endl;  // 쓰레기 값
free(obj);
// ✅ new: 생성자 호출
MyClass* obj2 = new MyClass();
std::cout << obj2->getValue() << std::endl;  // 0
delete obj2;

문제 3: 배열 delete 누락

증상: 메모리 누수 아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// ❌ delete 사용 (배열은 delete[])
int* arr = new int[10];
delete arr;  // ❌ 메모리 누수 가능
// ✅ delete[] 사용
int* arr2 = new int[10];
delete[] arr2;

문제 4: 타입 크기 실수

증상: 버퍼 오버플로우 아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// ❌ 크기 실수
int* arr = (int*)malloc(10);  // 10바이트 (int 2.5개?)
arr[5] = 42;  // 버퍼 오버플로우
// ✅ 올바른 크기
int* arr2 = (int*)malloc(10 * sizeof(int));  // int 10개
arr2[5] = 42;
free(arr2);
// 또는 new
int* arr3 = new int[10];  // 크기 자동
arr3[5] = 42;
delete[] arr3;

마무리

C++에서는 new를 사용하세요. malloc은 생성자를 호출하지 않아 객체가 제대로 초기화되지 않습니다.

핵심 요약

  1. new vs malloc
    • new: 생성자 호출, 타입 안전, 예외
    • malloc: 메모리만 할당, 캐스팅 필요, nullptr
  2. 선택 기준
    • C++ 클래스: new (생성자 필요)
    • C 라이브러리 연동: malloc
    • 일반적인 경우: 스마트 포인터
  3. 혼용 금지
    • malloc-free, new-delete 짝 맞추기
    • 혼용 시 미정의 동작
  4. 성능
    • 거의 차이 없음
    • new는 malloc + 생성자

선택 가이드

상황권장이유
C++ 클래스new생성자 호출 필요
기본 타입new타입 안전성
C 라이브러리 연동mallocC 코드와 호환
placement newmalloc + new메모리 풀
일반적인 경우스마트 포인터자동 해제

코드 예제 치트시트

다음은 cpp를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// malloc
int* ptr1 = (int*)malloc(sizeof(int));
free(ptr1);
// new
int* ptr2 = new int(42);
delete ptr2;
// 배열
int* arr1 = (int*)malloc(10 * sizeof(int));
free(arr1);
int* arr2 = new int[10];
delete[] arr2;
// 스마트 포인터
auto ptr3 = std::make_unique<int>(42);
auto arr3 = std::make_unique<int[]>(10);
// C 라이브러리 래핑
std::unique_ptr<char, decltype(&free)> ptr4(c_function(), free);

다음 단계

참고 자료

  • “Effective C++” - Scott Meyers
  • “C++ Primer” - Stanley Lippman
  • cppreference: https://en.cppreference.com/w/cpp/memory 한 줄 정리: C++에서는 생성자 호출과 타입 안전성을 위해 new를 사용하고, 가능하면 스마트 포인터로 자동 해제를 보장한다.
... 996 lines not shown ... Token usage: 63706/1000000; 936294 remaining Start-Sleep -Seconds 3