防止类的临时实例化

Question

How can I prevent instantiation of temporary instances of a certain class?

I've tried creating a method which can be called upon lvalue instances only and calling that method in the c'tor to prevent rvalue instantiations of the class in compile-time, but it didn't help -- the method was called successfully even for rvalue instantiations of the class. It seems that the c'tor is oblivious to the fact that it's currently constructing an rvalue instance; lvalue-only method calls are allowed either way.

My goal is to create a scoped guard for allocations returned by WinApi , which must be freed via LocalFree . I want to prevent from temporary instances of the class, which would cause immediate deallocation of the allocation, defeating the purpose of being a scoped guard. This might also cause unpredictable runtime behavior, because memory freed by LocalFree might still be accessible for some time after the function call.

Answer 1

If I interpret the question correctly, you should be fine with a RAII wrapper around your resource.

Here's an outline of how that could look:

#include <Windows.h>

#include <string>
#include <stdexcept>
#include <utility>

template<typename T>
class [[nodiscard]] ScopedAlloc {
public:
    ScopedAlloc(UINT uFlags, SIZE_T elems) : 
        hRes(LocalAlloc(uFlags, elems*sizeof(T)))
    {
        if (hRes == nullptr)
            throw std::runtime_error("ScopedAlloc failed " +
                                     std::to_string(GetLastError()));
    }

    // A constructor to take ownership of a HLOCAL created with LocalAlloc
    explicit ScopedAlloc(HLOCAL res) : hRes(res) {
        if(LocalSize(hRes) == 0)
            throw std::runtime_error("ScopedAlloc failed " +
                                     std::to_string(GetLastError()));
    }

    ScopedAlloc(const ScopedAlloc&) = delete; // or let it allocate and copy
    ScopedAlloc(ScopedAlloc&& rhs) : hRes(std::exchange(rhs.hRes, nullptr)) {}
    ScopedAlloc& operator=(const ScopedAlloc&) = delete; // or LocalReAlloc and copy
    ScopedAlloc& operator=(ScopedAlloc&& rhs) {
        std::swap(hRes, rhs.hRes);
        return *this;
    }

    ~ScopedAlloc() {
#ifndef NDEBUG
        if (hRes) { // fill memory with garbage in debug mode
            SIZE_T size = LocalSize(hRes);
            if (size) std::memset(hRes, 0xdd, size); // 0xDD - Dead Memory pattern
        }
#endif
        LocalFree(hRes);
    }

    operator const T* () const { return static_cast<T*>(hRes); }
    operator T* () { return static_cast<T*>(hRes); }

private:
    HLOCAL hRes;
};

Example usage:

#include <iostream>

struct bar { int x, y; };

std::ostream& operator<<(std::ostream& os, const bar& b) {
    return os << '{' << b.x << ',' << b.y << '}';
}

int main() {
    ScopedAlloc<bar> foo(LMEM_FIXED | LMEM_ZEROINIT, 2);
    foo[0] = {1, 2};
    foo[1] = {3, 4};
    std::cout << foo[0] << ", " << foo[1] << '\n';    // prints   {1,2}, {3,4}
}