WriteProcessMemory std::vector<any> 定制任何 class</any>

Question

How would i use Write Process Memory with a std::vector

This works if i use std::vector

Im not sure if this any class is returning right info when using.Data()

class any
{
private:
    struct base {
        virtual ~base() {}
        virtual base* clone() const = 0;
    };
    template <typename T>
    struct data : base {
        data(T const& value) : value_(value) {}
        base* clone() const { return new data<T>(*this); }
        T value_;
    };
    base* ptr_;
public:
    template <typename T> any(T const& value) : ptr_(new data<T>(value)) {}
    any(any const& other) : ptr_(other.ptr_->clone()) {}
    any& operator= (any const& other) {
        any(other).swap(*this);
        return *this;
    }
    ~any() { delete this->ptr_; }
    void swap(any& other) { std::swap(this->ptr_, other.ptr_); }

    template <typename T>
    T& get() {
        return dynamic_cast<data<T>&>(*this->ptr_).value_;
    }
};

template<typename T>
size_t vectorsizeof(const typename std::vector<T>& vec)
{
    return sizeof(T) * vec.size();
}

std::vector<any> args{100, 1.1f};
WriteProcessMemory(hProc, pMemory, args.data(), vectorsizeof(args), nullptr)

Answer 1

There has to be a easy way to use std::any in a vector with Write Process Memory.

No, there does not.

Ignoring what std::any does with the value it stores for the moment, std::any stores its value (as if) indirectly. This means that it is rather like a vector<T> ; it stores a pointer to the object which it allocated on the heap (except the T is hidden from the type and it only stores one of them). So copying the bits of the any itself will not (necessarily) make the T it stores visible; you are (may be) copying a pointer, not what it points to.

Furthermore, any can't be delivered across processes like this, for many reasons. Even if you could get access to the byte-range of the object being stored by an any , you wouldn't be able to use that to reconstruct the any on the other side. And even if you somehow could, you'd somehow have to transmit the type_index that represents the type stored in the any . And that isn't cross-process compatible; a type index value for a particular type in one process can be different from the index for the same type in the other process.

What you want simply isn't going to work. You'll have to use something else, and that something else is going to have to have some knowledge of the type of data it's transmitting.