어떤 경우에 malloc 및 / 또는 new를 사용합니까?

C ++에는 데이터를 할당하고 해제하는 여러 가지 방법이 있으며 전화를 걸면 이해합니다. malloc 를 걸고 연산자를 free사용할 때 new페어링해야 delete하며 두 가지를 혼합하는 것은 실수라는 것을 이해합니다 (예 : free()생성 된 무언가에 대한 호출) 와 new) 연산자,하지만 난 사용해야하는 경우에 명확하지 않다 malloc/ free내가 사용해야 할 때 new/ delete내 실제 프로그램입니다.

C ++ 전문가 인 경우 이와 관련하여 따르는 경험 규칙이나 규칙을 알려주십시오.

C를 사용하지 않으면을 사용해서는 안됩니다 malloc . 항상 사용하십시오 new.

많은 양의 데이터가 필요한 경우 다음과 같이하십시오.

char *pBuffer = new char[1024];

이것이 올바르지는 않지만주의하십시오.

//This is incorrect - may delete only one element, may corrupt the heap, or worse...
delete pBuffer;

대신 데이터 배열을 삭제할 때이 작업을 수행해야합니다.

//This deletes all items in the array
delete[] pBuffer;

new키워드는 그 일의 C ++ 방법이며, 그것은 당신의 유형이 그 것이다 보장합니다 생성자가 호출 . new키워드는 더 형태 보증 된 반면 malloc입력-로부터 안전하지 않습니다 전혀.

내가 유용하다고 생각할 수있는 유일한 방법 은 데이터 버퍼 의 크기malloc 를 변경 해야하는 경우 입니다. new키워드는 같은 유사한 방법이 없습니다 realloc. 이 realloc기능은 메모리 청크 크기를보다 효율적으로 확장 할 수 있습니다.

new/ free및 malloc/을 혼합 할 수는 없습니다 delete.

참고 :이 질문에 대한 일부 답변이 잘못되었습니다.

int* p_scalar = new int(5);  // Does not create 5 elements, but initializes to 5
int* p_array  = new int[5];  // Creates 5 elements

짧은 대답은 mallocC ++에 사용하지 않는 것이 좋습니다. mallocC ++과 함께 사용 new하면 극복 할 수있는 많은 결함이 있습니다.

C ++ 코드의 새로운 기능으로 해결 된 결함

1. malloc의미있는 방식으로 타입 안전하지 않습니다. C ++에서는에서 반환을 캐스트해야합니다 void*. 잠재적으로 많은 문제가 발생합니다.

   #include <stdlib.h>
   
   struct foo {
     double d[5];
   }; 
   
   int main() {
     foo *f1 = malloc(1); // error, no cast
     foo *f2 = static_cast<foo*>(malloc(sizeof(foo)));
     foo *f3 = static_cast<foo*>(malloc(1)); // No error, bad
   }

2. 그래도 더 나쁘다. 문제의 유형이 POD (일반 데이터) 인 경우 첫 번째 예에서 malloc와 같이 반 감각으로 메모리를 할당 하는 데 사용할 수 있습니다 f2.

   유형이 POD인지는 분명하지 않습니다. 주어진 유형이 컴파일러 오류가 발생하지 않고 문제를 디버깅하기가 매우 어려워 POD에서 비 POD로 변경 될 수 있다는 사실이 중요한 요소입니다. 예를 들어, 유지 관리 중 누군가 나중에 foo더 이상 POD가 아닌 변경을 수행 한 경우 컴파일 타임에 원하는대로 명백한 오류가 나타나지 않습니다. 예를 들면 다음과 같습니다.

   struct foo {
     double d[5];
     virtual ~foo() { }
   };

   만들 것 malloc의 f2명백한 진단하지 않고, 또한이 될 나쁜. 여기의 예는 사소한 것이지만 실수로 비 POD를 훨씬 더 멀리 도입 할 수 있습니다 (예 : 기본 클래스에서 비 POD 멤버를 추가하여). C ++ 11 / boost is_pod가있는 경우이 가정이 올바른지 확인하고 올바르지 않은 경우 오류를 생성하는 데 사용할 수 있습니다 .

   #include <type_traits>
   #include <stdlib.h>
   
   foo *safe_foo_malloc() {
     static_assert(std::is_pod<foo>::value, "foo must be POD");
     return static_cast<foo*>(malloc(sizeof(foo)));
   }

   boost는 형식이 C ++ 11 또는 다른 컴파일러 확장이없는 POD인지 확인할 수 없지만 .

3. mallocNULL할당이 실패하면를 반환 합니다. new던질 것 std::bad_alloc입니다. 나중에 NULL포인터를 사용하는 동작 은 정의되어 있지 않습니다. 예외가 발생하면 예외가 깨끗하고 오류의 원인에서 발생합니다. 포장 malloc모든 호출에서 적절한 검사와 함께하는 경향이 지루하고 오류가 보인다. (좋은 일을 모두 취소하기 위해서는 한 번만 잊어야합니다). 예외적으로 호출자가 의미있게 처리하기 NULL가 훨씬 어려운 수준에서 호출자가 처리 할 수있는 수준으로 전파 될 수 있습니다 . safe_foo_malloc예외를 발생 시키거나 프로그램을 종료하거나 핸들러를 호출하도록 함수를 확장 할 수 있습니다 .

   #include <type_traits>
   #include <stdlib.h>
   
   void my_malloc_failed_handler();
   
   foo *safe_foo_malloc() {
     static_assert(std::is_pod<foo>::value, "foo must be POD");
     foo *mem = static_cast<foo*>(malloc(sizeof(foo)));
     if (!mem) {
        my_malloc_failed_handler();
        // or throw ...
     }
     return mem;
   }

4. 기본적 malloc으로 C 기능이며 newC ++ 기능입니다. 결과적 malloc으로 생성자와 잘 작동하지 않으므로 바이트 덩어리 할당 만 살펴 봅니다. safe_foo_malloc게재 위치를 사용하도록 추가 확장 할 수 있습니다 new.

   #include <stdlib.h>
   #include <new>
   
   void my_malloc_failed_handler();
   
   foo *safe_foo_malloc() {
     void *mem = malloc(sizeof(foo));
     if (!mem) {
        my_malloc_failed_handler();
        // or throw ...
     }
     return new (mem)foo();
   }

5. 우리의 safe_foo_malloc기능은 매우 일반적이지 않습니다. 이상적으로는 모든 유형을 처리 할 수있는 것을 원할 것입니다 foo. 기본이 아닌 생성자를위한 템플릿 및 가변 템플릿을 사용하여이를 달성 할 수 있습니다.

   #include <functional>
   #include <new>
   #include <stdlib.h>
   
   void my_malloc_failed_handler();
   
   template <typename T>
   struct alloc {
     template <typename ...Args>
     static T *safe_malloc(Args&&... args) {
       void *mem = malloc(sizeof(T));
       if (!mem) {
          my_malloc_failed_handler();
          // or throw ...
       }
       return new (mem)T(std::forward(args)...);
     }
   };

   이제 우리가 지금까지 식별 한 모든 문제를 해결함에있어 기본 new연산자를 실제로 재창조했습니다 . 당신이 사용 malloc하고 배치 하려는 경우, 당신은 new뿐만 아니라 new시작 하는 데 사용할 수 있습니다 !

로부터 C ++ FQA 라이트 :

[16.4] 신뢰할 수있는 오래된 malloc () 대신 new를 사용해야하는 이유는 무엇입니까?

FAQ : 생성자 / 소멸자를 호출 / 삭제합니다. new는 타입이 안전하고 malloc은 그렇지 않습니다. new는 클래스에 의해 재정의 될 수 있습니다.

FQA : 생성자, 소멸자 및 연산자 오버로딩이 가비지 (가비지 수집이 없을 때 발생하는 일 참조) 및 유형 안전 문제가 실제로 매우 작기 때문에 FAQ에서 언급 한 새로운 미덕은 미덕이 아닙니다. malloc이 리턴 한 void *를 올바른 포인터 유형으로 캐스트하여 유형이 지정된 포인터 변수에 할당합니다.

오, 신뢰할 수있는 오래된 malloc을 사용하면 똑같이 신뢰할 수 있고 오래된 realloc을 사용할 수 있습니다. 유감스럽게도 우리에게는 새로운 운영자 갱신이나 무언가가 없습니다.

그럼에도 불구하고, 언어가 C ++ 인 경우에도 언어 전체에 사용되는 공통 스타일과의 편차를 정당화하기에 충분하지 않은 것은 새로운 것이 아닙니다. 특히 사소하지 않은 생성자를 가진 클래스는 단순히 객체를 malloc하면 치명적인 방식으로 잘못 작동합니다. 그렇다면 코드 전체에서 new를 사용하지 않는 이유는 무엇입니까? 사람들은 운영자에게 새로운 과부하를 거의주지 않기 때문에 너무 방해가되지 않을 것입니다. 새로운 과부하가 발생하면 언제든지 중지하도록 요청할 수 있습니다.

죄송합니다. 저항 할 수 없었습니다. :)

항상 C ++에서 new를 사용하십시오. 형식화되지 않은 메모리 블록이 필요한 경우 연산자 new를 직접 사용할 수 있습니다.

void *p = operator new(size);
   ...
operator delete(p);

사용하다 malloc 및 단지 C-중심의 라이브러리와 API에 의해 관리 될 것입니다 메모리를 할당합니다. 제어하는 모든 항목에 및 (및 변형)을 사용하십시오 .free newdelete[]

새로운 대 malloc ()

1) new이다 연산자 반면malloc() A는 기능 .

2) 생성자new 호출 하지만 malloc()그렇지 않습니다.

3) 정확한 데이터 유형을new 반환 하는 동안malloc() 반환 무효 * .

4) new절대 반환하지 않습니다 NULL 동안 (실패가 발생합니다) malloc()반환 NULL을

5) 메모리의 재 할당에 의해 처리되지 않는 new동안 malloc()캔

귀하의 질문에 대답하기 위해, 당신은 알아야 사이의 차이를 malloc와new . 차이점은 간단합니다.

malloc 메모리 를 new 할당하고 메모리 를 할당하고 메모리 를 할당 하는 객체 의 생성자 를 호출합니다 .

따라서 C로 제한되지 않는 한, 특히 C ++ 객체를 다룰 때 malloc을 사용해서는 안됩니다. 그것은 프로그램을 깨기위한 레시피 일 것입니다.

또한 사이의 차이 free와는 delete상당히 동일합니다. 차이점은 delete메모리를 비우는 것 외에도 객체의 소멸자를 호출 한다는 것입니다.

malloc와 사이에는 큰 차이가 new있습니다.malloc메모리를 할당합니다. C에서는 메모리가 대량이기 때문에 C에 적합합니다.

C ++에서 POD 유형 (C 유형과 유사한)을 처리하지 않는 경우 실제로 메모리 위치에서 생성자를 호출하여 객체를 가져와야합니다. 많은 C ++ 기능이 개체를 자동으로 비 POD로 만들기 때문에 비 POD 유형은 C ++에서 매우 일반적입니다.

new메모리를 할당 하고 해당 메모리 위치에 객체를 만듭니다. 비 POD 유형의 경우 생성자를 호출하는 것을 의미합니다.

이런 식으로하면 :

non_pod_type* p = (non_pod_type*) malloc(sizeof *p);

획득 한 포인터는 객체를 가리 키지 않으므로 역 참조 할 수 없습니다. 사용하기 전에 생성자를 호출해야합니다 (이것은 배치를 사용하여 수행됩니다)new ).

반면에 다음과 같은 경우 :

non_pod_type* p = new non_pod_type();

항상 유효한 포인터를 얻습니다. new객체를 생성 습니다.

POD 유형의 경우에도 둘 사이에는 큰 차이가 있습니다.

pod_type* p = (pod_type*) malloc(sizeof *p);
std::cout << p->foo;

이 코드는 작성된 POD 오브젝트 malloc가 초기화되지 않았기 때문에 지정되지 않은 값을 인쇄합니다 .

을 사용하면 new호출 할 생성자를 지정하여 잘 정의 된 값을 얻을 수 있습니다.

pod_type* p = new pod_type();
std::cout << p->foo; // prints 0

실제로 원하는 경우 new초기화를 사용 하여 초기화되지 않은 POD 객체를 얻을 수 있습니다 . 이에 대한 자세한 내용 은 이 다른 답변 을 참조하십시오.

또 다른 차이점은 실패시 동작입니다. 메모리 할당에 실패하면 mallocnull 포인터를 반환 new하고 예외 를 throw합니다.

전자는 사용하기 전에 반환 된 모든 포인터를 테스트해야하지만 후자는 항상 유효한 포인터를 생성합니다.

이러한 이유로 C ++ 코드에서는을 사용 new하지 말고을 사용해야 malloc합니다. 그러나 new"개방형"을 사용해서는 안됩니다 . 나중에 공개해야하는 리소스를 확보하기 때문입니다. 사용할 때 new결과를 즉시 자원 관리 클래스로 전달해야합니다.

std::unique_ptr<T> p = std::unique_ptr<T>(new T()); // this won't leak

동적 할당은 객체의 수명이 생성 된 범위와 달라야하고 (범위를 더 작게 만들기 위해 유지됨) 값별로 저장하지 않는 특정 이유가있는 경우에만 필요합니다. 작업.

예를 들면 다음과 같습니다.

 std::vector<int> *createVector(); // Bad
 std::vector<int> createVector();  // Good

 auto v = new std::vector<int>(); // Bad
 auto result = calculate(/*optional output = */ v);
 auto v = std::vector<int>(); // Good
 auto result = calculate(/*optional output = */ &v);

C ++ 11부터 std::unique_ptr할당 된 메모리의 소유권을 포함하는 할당 된 메모리를 처리 해야 합니다.std::shared_ptr소유권을 공유해야 할 때 생성되었습니다. (좋은 프로그램에서 기대하는 것보다 덜 필요합니다)

인스턴스 만들기가 정말 쉬워집니다.

auto instance = std::make_unique<Class>(/*args*/); // C++14
auto instance = std::make_unique<Class>(new Class(/*args*/)); // C++11
auto instance = std::make_unique<Class[]>(42); // C++14
auto instance = std::make_unique<Class[]>(new Class[](42)); // C++11

C ++ 17은 또한 std::optional메모리 할당을 요구하지 않도록 추가합니다.

auto optInstance = std::optional<Class>{};
if (condition)
    optInstance = Class{};

'인스턴스'가 범위를 벗어나면 메모리가 정리됩니다. 소유권 이전도 쉽습니다.

 auto vector = std::vector<std::unique_ptr<Interface>>{};
 auto instance = std::make_unique<Class>();
 vector.push_back(std::move(instance)); // std::move -> transfer (most of the time)

그래서 언제 아직도 필요 new합니까? C ++ 11부터는 거의 없습니다. 대부분은 std::make_unique원시 포인터를 통해 소유권을 이전하는 API에 도달 할 때까지 사용 합니다.

 auto instance = std::make_unique<Class>();
 legacyFunction(instance.release()); // Ownership being transferred

 auto instance = std::unique_ptr<Class>{legacyFunction()}; // Ownership being captured in unique_ptr

C ++ 98 / 03에서는 수동 메모리 관리를 수행해야합니다. 이 경우 최신 버전의 표준으로 업그레이드하십시오. 붙어있는 경우 :

 auto instance = new Class(); // Allocate memory
 delete instance;             // Deallocate
 auto instances = new Class[42](); // Allocate memory
 delete[] instances;               // Deallocate

메모리 누수가 없도록 소유권을 올바르게 추적해야합니다! 이동 의미론도 아직 작동하지 않습니다.

그렇다면 C ++에서 malloc이 언제 필요할까요? 유효한 이유는 메모리를 할당하고 나중에 new 배치를 통해 메모리를 초기화하는 것입니다.

 auto instanceBlob = std::malloc(sizeof(Class)); // Allocate memory
 auto instance = new(instanceBlob)Class{}; // Initialize via constructor
 instance.~Class(); // Destroy via destructor
 std::free(instanceBlob); // Deallocate the memory

위의 내용이 유효하더라도 새로운 운영자를 통해서도 가능합니다. std::vector이에 대한 좋은 예입니다.

마지막으로, 우리는 여전히 방에 코끼리가 있습니다 C. 메모리가 C ++ 코드에서 할당되고 C 코드에서 해제되거나 다른 방법으로 해제되는 C 라이브러리로 작업해야하는 경우 malloc / free를 사용해야합니다.

이 경우 가상 함수, 멤버 함수, 클래스를 잊어 버리십시오 ... POD가있는 구조체 만 허용됩니다.

규칙에 대한 일부 예외 :

• malloc이 적합한 고급 데이터 구조로 표준 라이브러리를 작성 중입니다.
• 많은 양의 메모리를 할당해야합니다 (10GB 파일의 메모리 사본?)
• 특정 구문을 사용하지 못하게하는 툴링이 있습니다.
• 불완전한 유형을 저장해야합니다

몇 가지가 있습니다 new것을 수행 malloc하지 않습니다는 :

1. new 해당 객체의 생성자를 호출하여 객체를 생성합니다.
2. new 할당 된 메모리의 타입 캐스팅이 필요하지 않습니다.
3. 할당 할 메모리 양이 필요하지 않고 여러 개체를 구성해야합니다.

따라서를 사용하는 경우 malloc위의 작업을 명시 적으로 수행해야합니다. 이는 항상 실용적이지는 않습니다. 또한 new오버로드 될 수는 있지만로드 malloc할 수 없습니다.

구성 / 파괴가 필요하지 않고 재 할당이 필요한 데이터 (예 : 큰 정수)가 필요한 경우 malloc / free가 realloc을 제공하므로 new-memcpy보다 훨씬 빠릅니다. -delete (내 Linux 상자에 있지만 플랫폼에 따라 다를 수 있습니다). POD가 아니고 구성 / 파괴가 필요한 C ++ 오브젝트로 작업하는 경우 new 및 delete 연산자를 사용해야합니다.

어쨌든, 속도 향상을 이용할 수 있다면 (때로는 큰 배열을 재 할당하는 경우 중요한 경우), 둘 다를 사용하지 않아야하는 이유를 알 수 없습니다. realloc이 줄 수 있습니다.

그래도 필요하지 않으면 C ++에서 새 / 삭제를 고수해야합니다.

C 코드를 C ++로 이식하려는 경우 malloc () 호출을 그대로 둘 수 있습니다. 새로운 C ++ 코드의 경우 new를 대신 사용하는 것이 좋습니다.

C ++를 사용하는 경우 malloc / calloc 대신 new / delete를 연산자로 사용하십시오. malloc / calloc의 경우 다른 헤더를 포함해야합니다. 동일한 코드에서 두 개의 다른 언어를 혼합하지 마십시오. 그들의 작업은 모든면에서 비슷하며 해시 테이블의 힙 세그먼트에서 동적으로 메모리를 할당합니다.

new 구조체의 기본값을 초기화하고 그 안의 참조를 자신에게 올바르게 연결합니다.

예 :

struct test_s {
    int some_strange_name = 1;
    int &easy = some_strange_name;
}

따라서 new struct test_smalloc'ed 버전에는 기본값이 없으며 인턴 참조는 초기화되지 않은 반면 작동하는 참조와 함께 초기화 된 구조를 반환합니다.

낮은 관점에서, new는 메모리를주기 전에 모든 메모리를 초기화하는 반면 malloc은 메모리의 원래 내용을 유지합니다.

다음 시나리오에서는 생성자를 호출하므로 new를 사용할 수 없습니다.

class  B  {
private:
    B *ptr;
    int x;
public:
    B(int n)  {
        cout<<"B: ctr"<<endl;
        //ptr = new B;  //keep calling ctr, result is segmentation fault
        ptr = (B *)malloc(sizeof(B));
        x = n;
        ptr->x = n + 10;
    }
    ~B()  {
        //delete ptr;
        free(ptr);
        cout<<"B: dtr"<<endl;
    }
};

new및 delete운영자는 반면, 클래스 및 구조에서 작동 할 수 malloc와 free필요가 캐스팅 될하는 메모리 블록에서만 작동합니다.

를 사용 new/delete하면 할당 된 메모리를 필요한 데이터 구조로 캐스트 할 필요가 없으므로 코드를 개선하는 데 도움이됩니다.

new / delete 대신 malloc / free를 사용하는 것을 고려하는 드문 경우는 C ++에서 realloc과 비슷한 기능이 없기 때문에 realloc을 사용하여 할당 한 다음 (객체가 아닌 간단한 포드 유형) 할당 할 때입니다 (이를 사용하여 수행 할 수는 있지만) 더 많은 C ++ 접근 방식).

malloc ()은 C에서 메모리를 동적으로 할당하는 데 사용되는 반면 동일한 작업은 c ++의 new ()에서 수행됩니다. 따라서 2 개 언어의 코딩 규칙을 혼합 할 수 없습니다. calloc과 malloc ()의 차이점을 요청하면 좋을 것입니다.