람다 펑터 할당 해결 방법

Question

아래 코드에 어떤 문제가 있습니까?

#include <iostream> 

#include <type_traits> 

template <typename T> 
void assign_lambda(T&& f) 
{ 
    typedef typename std::remove_reference<T>::type functor_type; 

    typedef typename std::aligned_storage<sizeof(functor_type), 
    std::alignment_of<functor_type>::value>::type buffer_type; 

    static char store[sizeof(buffer_type)]; 

    auto const p(new (store) functor_type(std::forward<T>(f))); 

    (*p)(); 
} 

int main() 
{ 
    for (int i(0); i != 5; ++i) 
    { 
    assign_lambda([i](){ std::cout << i << std::endl; }); 
    } 

    return 0; 
} 

비표준이거나 위험 할 수 있습니다.

편집 : char 어레이로 초기화하는 이유는 무엇입니까? 힙에서 크기가 sizeof(buffer_type) 인 블록을 할당하고 블록이 충분히 커야하는 경우 반복 할당 (예 : 반복 메모리 할당 방지)을 위해 재사용 할 수 있습니다.

void * operator new (std :: size_t size);

효과 : 할당 함수 (3.7.4.1)는 해당 크기의 모든 객체를 나타 내기 위해 적절히 정렬 된 저장소의 크기 바이트를 할당하기 위해 새 표현식 (5.3.4)을 호출합니다.

힙에서 할당하면 정렬 문제가 사라집니다.

Answer 1

store에 functor_type의 적절한 정렬이 있는지 확인해야합니다. 그 외에도 표준 준수와 관련하여 어떤 문제도 보이지 않습니다. 그러나 sizeof은 컴파일 타임 상수를 제공하므로 배열을 nonstatic으로 만들어 멀티 스레딩 문제를 쉽게 해결할 수 있습니다.

배향 §5.3.4,14이 요구된다

[참고 : 할당 함수가 널이 아닌 값을 반환 할 때, 스토리지의 블럭에 대한 포인터되어야하는 개체의 공간이 예약되었습니다. 저장소 블록은 적절하게 정렬되고 요청 된 크기로 간주됩니다. [...] - end note]

정렬에 관한 §3.7.4.1 절이 있지만 새로 배치 (18.6.1.3,1)에는 명시 적으로 적용되지 않습니다.

정렬 권리를 얻으려면, 다음을 수행 할 수 있습니다

template <typename T> 
void assign_lambda(T&& f) 
{ 
    typedef typename std::remove_reference<T>::type functor_type; 

    //alignas(functor_type) char store[sizeof(functor_type)]; 
    std::aligned_storage<sizeof(functor_type), 
      std::alignment_of<functor_type>::value>::type store; 

    auto const p(new (&store) functor_type(std::forward<T>(f))); 

    (*p)(); 

    //"placement delete" 
    p->~functor_type(); 
} 

업데이트 :

template <typename T> 
void assign_lambda(T&& f) 
{ 
    typedef typename std::remove_reference<T>::type functor_type; 

    functor_type func{std::forward<T>(f)}; 

    func(); 
} 

경우 : 위에 표시된 접근 방식은 일반 변수를 사용하여 다르지 않다 그것 은이 함수 내에서 정적 변수가되어야 할당 할 수없는 펑터에 대한 RAII 래퍼가 필요합니다. 펑터가 제대로 파괴되지 않고 보유한 자원 (예 : 캡처 된 스마트 포인터를 통해)이 해제되지 않기 때문에 배치 재 작성만으로는 충분하지 않습니다.

template <typename F> 
struct RAIIFunctor { 
    typedef typename std::remove_reference<F>::type functor_type; 

    std::aligned_storage<sizeof(functor_type), 
      std::alignment_of<functor_type>::value>::type store; 

    functor_type* f; 

    RAIIFunctor() : f{nullptr} {} 
    ~RAIIFunctor() { destroy(); } 

    template <class T> 
    void assign(T&& t) { 
    destroy(); 
    f = new(&store) functor_type {std::forward<T>(t)}; 
    } 

    void destroy() { 
    if (f) 
     f->~functor_type(); 
    f = nullptr; 
    } 

    void operator() { 
    (*f)(); 
    } 
}; 


template <typename T> 
void assign_lambda(T&& f) 
{ 
    static RAIIFunctor<T> func; 

    func.assign(std::forward<T>(f)); 
    func(); 
} 

당신은 내가 그것을 얻을하지 않는 행동 here

Answer 2

의 코드를 볼 수 있습니다. 왜 aligned_storage을 사용하여 초기화되지 않은 저장소를 만드는 대신 크기가 좀 나가면 정렬 된 저장소를 사용하는 것일까 요? 그것은 거의 베를린에서 리스본으로 여행하는 것과 같습니다 -> 리스본 비행에 이어 리스본 -> 모스크바 비행.이미 배치 new을 통해 람다의 복사본을 만들하지만 당신은 사본을 파괴하지 않는 언급 정렬 문제 외에도

typedef typename std::remove_reference<T>::type functor_type; 

    typedef typename std::aligned_storage<sizeof(functor_type), 
    std::alignment_of<functor_type>::value>::type buffer_type; 

    static buffer_type store; 

    auto const p(new (&store) functor_type(std::forward<T>(f))); 

Answer 3

.

// This class plays the role of the OP's lambdas 
struct Probe { 
    Probe() { std::cout << "Ctr" << '\n'; } 
    Probe(const Probe&) { std::cout << "Cpy-ctr" << '\n'; } 
    ~Probe() { std::cout << "Dtr" << '\n'; } 

}; 

// This plays the role of the OP's assign_lambda 
void f(const Probe& p) { 

    typedef typename std::aligned_storage<sizeof(Probe), 
     std::alignment_of<Probe>::value>::type buffer_type; 

    static buffer_type store; 
    new (&store) Probe(p); 
} 

int main() { 

    Probe p; 

    // This plays the role of the loop 
    f(p); 
    f(p); 
    f(p); 
} 

출력은 :

다음 코드는 문제 도시

Ctr 
Cpy-ctr 
Cpy-ctr 
Cpy-ctr 
Dtr 

그러므로, 4 개체가 구성된다를 하나만이 파괴된다.

또한 OP 코드에서 store은 static이며 이것은 하나의 람다가 마치 원시 메모리 인 것처럼 반복적으로 다른 하나의 람다가 반복적으로 구성된다는 것을 의미합니다.