배열과 함께 unique_ptr을 사용합니까?

std::unique_ptr 예를 들어 배열을 지원합니다.

std::unique_ptr<int[]> p(new int[10]);

그러나 필요합니까? 아마도 사용하는 것이 더 편리하다 std::vector나 std::array.

그 구조에 대한 사용을 찾으십니까?

일부 사람들은 std::vector할당자를 사용 하더라도 고급 기능을 사용할 수 없습니다 . 어떤 사람들은 동적 크기의 배열을 필요로 std::array합니다. 그리고 어떤 사람들은 배열을 반환하는 것으로 알려진 다른 코드에서 배열을 얻습니다. 그 코드는 vector또는 다른 것을 반환하기 위해 다시 작성되지 않습니다 .

을 허용 unique_ptr<T[]>하면 해당 요구 를 처리 할 수 있습니다.

요컨대, 필요할unique_ptr<T[]> 때 사용 합니다. 대안이 단순히 효과가 없을 때. 최후의 수단입니다.

트레이드 오프가 있으며 원하는 것과 일치하는 솔루션을 선택합니다. 내 머리 꼭대기에서 :

초기 크기

• vector그리고 unique_ptr<T[]>크기는 실행 시간에 지정할 수 있습니다
• array 컴파일시 크기 만 지정할 수 있습니다.

크기 조정

• array및 unique_ptr<T[]>크기 조정 허용하지 않습니다
• vector 않습니다

저장

• vector및 unique_ptr<T[]>(일반적 힙) 객체 외부에 데이터를 저장할
• array 객체에 데이터를 직접 저장

사자

• array그리고 vector복사를 허용
• unique_ptr<T[]> 복사를 허용하지 않습니다

스왑 / 이동

• vector및 unique_ptr<T[]>O (1)이 시간 swap및 이동 동작을
• arrayO (n) 시간 swap및 이동 연산이 있으며 여기서 n은 배열의 요소 수입니다.

포인터 / 참조 / 반복자 무효화

• array 객체가 활성화되어있는 동안에도 포인터, 참조 및 반복자가 무효화되지 않도록합니다. swap()
• unique_ptr<T[]>반복자가 없습니다. 포인터와 참조는 swap()객체가 활성화되어있는 동안에 만 무효화됩니다 . 스와핑 한 후에는 포인터가 스왑 한 배열을 가리 키므로 여전히 그런 의미에서 "유효"합니다.
• vector 재 할당에서 포인터, 참조 및 반복자를 무효화 할 수 있습니다 (재 할당이 특정 작업에서만 발생할 수 있음을 보장합니다).

개념 및 알고리즘과의 호환성

• array그리고 vector둘 다 컨테이너입니다
• unique_ptr<T[]> 컨테이너가 아닙니다

정책 기반 설계로 리팩토링 할 수있는 기회 인 것 같습니다.

a를 사용하는 한 가지 이유 는 배열 unique_ptr의 값을 초기화 하는 런타임 비용을 지불하고 싶지 않기 때문 입니다.

std::vector<char> vec(1000000); // allocates AND value-initializes 1000000 chars

std::unique_ptr<char[]> p(new char[1000000]); // allocates storage for 1000000 chars

std::vector생성자와 std::vector::resize()초기화 값 것이다 T- 그러나 new경우는 그렇게하지 않을 것이다 T포드입니다.

C ++ 11 및 std :: vector 생성자의 Value-Initialized Objects 참조

참고 vector::reserve여기에 대안이 아니다는 : 표준 : : 벡터 후에 원시 포인터에 액세스 :: 예비 안전?

그것은 C 프로그래머가 선택할 수 같은 이유 malloc이상 calloc.

는 std::vector동안, 주변에 복사 할 수 있습니다 unique_ptr<int[]>배열의 고유 한 소유권을 표현 할 수 있습니다. std::array반면에, 컴파일 타임에 크기를 결정해야하므로 일부 상황에서는 불가능할 수 있습니다.

Scott Meyers는 Effective Modern C ++에서 다음과 같이 말합니다.

의 존재 std::unique_ptr배열이 있기 때문에, 당신 만 지적 관심을해야한다 std::array, std::vector,std::string 거의 항상 원시 배열보다 더 나은 데이터 구조의 선택입니다. 내가 std::unique_ptr<T[]>이해할 수있는 유일한 상황에 대해서는 소유권이 있다고 가정하는 힙 배열에 대한 원시 포인터를 반환하는 C와 같은 API를 사용하는 경우가 될 것입니다.

Charles Salvia의 대답은 관련이 있다고 생각합니다 std::unique_ptr<T[]>. 컴파일시 크기를 알 수없는 빈 배열을 초기화하는 유일한 방법입니다. Scott Meyers는 이러한 사용 동기에 대해 무엇을 말해야 std::unique_ptr<T[]>합니까?

반대로 std::vector하고 std::array, std::unique_ptrNULL 포인터를 소유 할 수 있습니다.
이것은 배열 또는 NULL을 기대하는 C API로 작업 할 때 유용합니다.

void legacy_func(const int *array_or_null);

void some_func() {    
    std::unique_ptr<int[]> ptr;
    if (some_condition) {
        ptr.reset(new int[10]);
    }

    legacy_func(ptr.get());
}

내가 사용했던 unique_ptr<char[]>게임 엔진에 사용되는 사전 할당 된 메모리 풀을 구현 할 수 있습니다. 아이디어는 충돌 요청 결과 및 각 프레임에서 메모리를 할당 / 해제하지 않고도 입자 물리와 같은 다른 것들을 반환하기 위해 동적 할당 대신 사용되는 미리 할당 된 메모리 풀을 제공하는 것입니다. 파괴 논리가 필요하지 않은 (메모리 할당 해제 만) 제한된 수명 시간 (일반적으로 1, 2 또는 3 프레임)으로 객체를 할당하기 위해 메모리 풀이 필요한 이러한 종류의 시나리오에는 매우 편리합니다.

일반적인 일부 패턴은 일부 Windows Win32 API 호출 에서 찾을 수 있습니다 std::unique_ptr<T[]>. 예를 들어 일부 Win32 API를 호출 할 때 출력 버퍼의 크기를 정확히 알지 못하는 경우 (예 : 내부에 데이터를 쓰는 경우) 해당 버퍼) :

// Buffer dynamically allocated by the caller, and filled by some Win32 API function.
// (Allocation will be made inside the 'while' loop below.)
std::unique_ptr<BYTE[]> buffer;

// Buffer length, in bytes.
// Initialize with some initial length that you expect to succeed at the first API call.
UINT32 bufferLength = /* ... */;

LONG returnCode = ERROR_INSUFFICIENT_BUFFER;
while (returnCode == ERROR_INSUFFICIENT_BUFFER)
{
    // Allocate buffer of specified length
    buffer.reset( BYTE[bufferLength] );
    //        
    // Or, in C++14, could use make_unique() instead, e.g.
    //
    // buffer = std::make_unique<BYTE[]>(bufferLength);
    //

    //
    // Call some Win32 API.
    //
    // If the size of the buffer (stored in 'bufferLength') is not big enough,
    // the API will return ERROR_INSUFFICIENT_BUFFER, and the required size
    // in the [in, out] parameter 'bufferLength'.
    // In that case, there will be another try in the next loop iteration
    // (with the allocation of a bigger buffer).
    //
    // Else, we'll exit the while loop body, and there will be either a failure
    // different from ERROR_INSUFFICIENT_BUFFER, or the call will be successful
    // and the required information will be available in the buffer.
    //
    returnCode = ::SomeApiCall(inParam1, inParam2, inParam3, 
                               &bufferLength, // size of output buffer
                               buffer.get(),  // output buffer pointer
                               &outParam1, &outParam2);
}

if (Failed(returnCode))
{
    // Handle failure, or throw exception, etc.
    ...
}

// All right!
// Do some processing with the returned information...
...

std::unique_ptr<bool[]>HDF5 라이브러리 (이진 데이터 저장을위한 라이브러리, 과학에서 많이 사용됨)에있는 을 사용해야하는 경우에 직면했습니다 . 일부 컴파일러 (필자의 경우 Visual Studio 2015) 는 압축에std::vector<bool> 신경 쓰지 않는 HDF5와 같은 재앙 인 (모든 바이트에 8 부울을 사용하여) 압축을 제공합니다. 를 사용 std::vector<bool>하면 HDF5는 압축으로 인해 결국 가비지를 읽었습니다.

std::vector작동하지 않는 경우 누가 구조를 위해 있었는지 추측 하고 동적 배열을 깨끗하게 할당해야합니까? :-)

요컨대, 메모리 효율성이 가장 뛰어납니다.

A std::string는 포인터, 길이 및 "짧은 문자열 최적화"버퍼와 함께 제공됩니다. 그러나 내 상황은 거의 항상 비어있는 문자열을 수십만 개의 구조로 저장해야한다는 것입니다. C에서는을 사용 char *하고 대부분의 경우 null이됩니다. char *소멸자가 없으며 자체 삭제를 모르는 것을 제외하고 C ++에서도 작동 합니다. 반대로 a std::unique_ptr<char[]>는 범위를 벗어날 때 자체를 삭제합니다. 빈칸 std::string은 32 바이트를 차지하지만 빈칸 std::unique_ptr<char[]>은 8 바이트를 차지합니다.

가장 큰 단점은 줄의 길이를 알고 싶을 때마다 전화해야한다는 strlen것입니다.

장치에서 메모리를 할당 할 때 GPU에서 CUDA 프로그래밍의 경우를 사용하는 vector대신 "사용해야한다고 생각하는 사람들에게 대답하려면 unique_ptr포인터 배열 (with cudaMalloc) 을 사용해야합니다 . 그런 다음 호스트에서이 데이터를 검색 할 때 포인터를 다시 찾아야하며 unique_ptr포인터를 쉽게 처리 할 수 ​​있습니다. 로 변환 double*하는 데 드는 추가 비용 vector<double>은 불필요하며 성능이 저하됩니다.

std::unique_ptr<T[]>지금까지 응답에서 언급되지 않은 을 허용하고 사용하는 한 가지 추가 이유 : 배열 요소 유형을 전달할 수 있습니다.

이는 #include빌드 성능을 최적화하기 위해 헤더 의 체인 문 을 최소화하려는 경우에 유용 합니다.

예를 들어-

myclass.h :

class ALargeAndComplicatedClassWithLotsOfDependencies;

class MyClass {
   ...
private:
   std::unique_ptr<ALargeAndComplicatedClassWithLotsOfDependencies[]> m_InternalArray;
};

myclass.cpp :

#include "myclass.h"
#include "ALargeAndComplicatedClassWithLotsOfDependencies.h"

// MyClass implementation goes here

위의 코드 구조를 #include "myclass.h"사용 MyClass하면에 필요한 내부 구현 종속성을 포함하지 않고도 누구나 사용할 수 있습니다 MyClass::m_InternalArray.

m_InternalArray대신 각각 std::array<ALargeAndComplicatedClassWithLotsOfDependencies>, 또는 로 선언 된 경우 std::vector<...>결과는 불완전한 유형의 사용을 시도하며 이는 컴파일 타임 오류입니다.

나는 받아 들여진 대답의 정신에 충분히 동의하지 않습니다. "최후의 수단"? 그것과는 거리가 멀다!

내가 보는 방법은 C와 다른 C ++에 비해 C ++의 가장 강력한 기능 중 하나는 제약 조건을 표현하여 컴파일 타임에 확인하고 실수로 오용되는 것을 방지 할 수 있다는 것입니다. 따라서 구조를 설계 할 때 어떤 작업을 허용 해야하는지 스스로에게 물어보십시오. 다른 모든 사용은 금지되어야하며, 이러한 제한을 정적으로 (컴파일 시간에) 구현하여 잘못 사용하면 컴파일이 실패하는 것이 가장 좋습니다.

따라서 배열이 필요할 때 다음 질문에 대한 대답은 동작을 지정합니다. 2. 스택에 어레이를 할당 할 수 있습니까?

그리고 답을 바탕으로, 이것은 그러한 배열에 가장 적합한 데이터 구조로 간주됩니다.

       Dynamic     |   Runtime static   |         Static
Stack std::vector      unique_ptr<T[]>          std::array
Heap  std::vector      unique_ptr<T[]>     unique_ptr<std::array>

그래, 내 생각에는 unique_ptr<std::array> 또한 고려해야 하며, 최후의 수단이 아니다. 알고리즘에 가장 적합한 것을 생각하십시오.

이 모든 것은 데이터 배열에 대한 원시 포인터 ( vector.data()/ array.data()/ uniquePtr.get()) 를 통해 일반 C API와 호환됩니다 .

PS 위의 고려 사항 외에도 소유권 중 하나가 있습니다. std::array 와 std::vector동시에, 값 의미를 (복사 한 값으로 전달하기위한 네이티브 지원이)가 unique_ptr<T[]>전용 (시행한다 단일 소유권을) 이동할 수 있습니다. 다른 시나리오에서 유용 할 수 있습니다. 반대로, 일반 정적 배열 ( int[N]) 및 일반 동적 배열 ( new int[10])은 둘 다를 제공하지 않으므로 가능하면 피해야합니다. 대부분의 경우 가능해야합니다. 이것으로 충분하지 않은 경우 일반 동적 배열은 크기를 쿼리 할 수있는 방법을 제공하지 않으므로 메모리 손상 및 보안 허점에 대한 추가 기회가 제공됩니다.

해치의 다른 쪽에서 "잡힌"후 수명이 측정되는 기존 API (창 메시지 또는 스레딩 관련 콜백 매개 변수)를 통해 단일 포인터 만 찌를 때 가능한 가장 올바른 대답 일 수 있습니다. 그러나 이것은 호출 코드와 관련이 없습니다.

unique_ptr<byte[]> data = get_some_data();

threadpool->post_work([](void* param) { do_a_thing(unique_ptr<byte[]>((byte*)param)); },
                      data.release());

우리 모두는 우리에게 좋은 일을 원합니다. 다른 때는 C ++입니다.

unique_ptr<char[]>C의 성능과 C ++의 편리함을 원하는 곳에서 사용할 수 있습니다. 수백만 개 (아직 신뢰할 수없는 경우 수십억 개)의 문자열을 조작해야한다고 생각하십시오. 각각을 개별 string또는 vector<char>오브젝트 에 저장 하면 메모리 (힙) 관리 루틴에 재앙이됩니다. 특히 다른 문자열을 여러 번 할당하고 삭제해야하는 경우.

그러나 많은 문자열을 저장하기 위해 단일 버퍼를 할당 할 수 있습니다. char* buffer = (char*)malloc(total_size);명백한 이유로 마음 에 들지 않을 것 입니다 (명확하지 않은 경우 "스마트 ptr을 사용하는 이유"를 검색하십시오). 당신은 오히려 좋아합니다unique_ptr<char[]> buffer(new char[total_size]);

비유로, 동일한 성능 및 편의성 고려 사항이 비 char데이터에 적용됩니다 (수백만 개의 벡터 / 행렬 / 개체 고려).

• 이진 호환성을 위해 포인터 만 포함하는 구조가 필요합니다.
• 할당 된 메모리를 반환하는 API와 인터페이스해야합니다. new[]
• std::vector예를 들어 부주의 한 프로그래머가 실수로 사본을 소개하지 않도록하기 위해 회사 나 프로젝트에을 사용하는 것에 대한 일반적인 규칙이 있습니다.
• 이 경우 부주의 한 프로그래머가 실수로 사본을 소개하지 않도록합니다.

포인터를 사용하여 롤링하는 것보다 C ++ 컨테이너를 선호하는 것이 일반적 규칙입니다. 일반적인 규칙입니다. 예외가 있습니다. 더있다; 이것들은 단지 예일뿐입니다.

복사 할 수없는 동적 객체 배열이 필요한 경우, 배열에 대한 스마트 포인터가 필요합니다. 예를 들어 원자 배열이 필요한 경우 어떻게해야합니까?