FatalExecutionEngineError on accessing a pointer set with memcpy_s

See update 1 below for my guess as to why the error is happening

I'm trying to develop an application with some C#/WPF and C++. I am having a problem on the C++ side on a part of the code that involves optimizing an object using GNU Scientific Library (GSL) optimization functions. I will avoid including any of the C#/WPF/GSL code in order to keep this question more generic and because the problem is within my C++ code.

For the minimal, complete and verifiable example below, here is what I have. I have a class Foo. And a class Optimizer. An object of class Optimizer is a member of class Foo, so that objects of Foo can optimize themselves when it is required.

The way GSL optimization functions take in external parameters is through a void pointer. I first define a struct Params to hold all the required parameters. Then I define an object of Params and convert it into a void pointer. A copy of this data is made with memcpy_s and a member void pointer optimParamsPtr of Optimizer class points to it so it can access the parameters when the optimizer is called to run later in time. When optimParamsPtr is accessed by CostFn(), I get the following error.

Managed Debugging Assistant 'FatalExecutionEngineError' : 'The runtime has encountered a fatal error. The address of the error was at 0x6f25e01e, on thread 0x431c. The error code is 0xc0000005. This error may be a bug in the CLR or in the unsafe or non-verifiable portions of user code. Common sources of this bug include user marshaling errors for COM-interop or PInvoke, which may corrupt the stack.'

Just to ensure the validity of the void pointer I made, I call CostFn() at line 81 with the void * pointer passed as an argument to InitOptimizer() and everything works. But in line 85 when the same CostFn() is called with the optimParamsPtr pointing to data copied by memcpy_s, I get the error. So I am guessing something is going wrong with the memcpy_s step. Anyone have any ideas as to what?

#include "pch.h"
#include <iostream>

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace std;

// An optimizer for various kinds of objects
class Optimizer // GSL requires this to be an unmanaged class
{
public:
    double InitOptimizer(int ptrID, void *optimParams, size_t optimParamsSize);
    void FreeOptimizer();
    void * optimParamsPtr;
private:
    double cost = 0;
};

ref class Foo // A class whose objects can be optimized
{
private:
    int a; // An internal variable that can be changed to optimize the object
    Optimizer *fooOptimizer; // Optimizer for a Foo object
public:
    Foo(int val) // Constructor
    {
        a = val;
        fooOptimizer = new Optimizer;
    }

    ~Foo()
    {
        if (fooOptimizer != NULL)
        {
            delete fooOptimizer;
        }
    }

    void SetA(int val) // Mutator
    {
        a = val;
    }

    int GetA() // Accessor
    {
        return a;
    }

    double Optimize(int ptrID); // Optimize object
    //  ptrID is a variable just to change behavior of Optimize() and show what works and what doesn't
};

ref struct Params // Parameters required by the cost function
{
    int cost_scaling;
    Foo ^ FooObj;
};

double CostFn(void *params) // GSL requires cost function to be of this type and cannot be a member of a class
{
    // Cast void * to Params type
    GCHandle h = GCHandle::FromIntPtr(IntPtr(params));
    Params ^ paramsArg = safe_cast<Params^>(h.Target);
    h.Free(); // Deallocate

    // Return the cost
    int val = paramsArg->FooObj->GetA();
    return (double)(paramsArg->cost_scaling * val);
}

double Optimizer::InitOptimizer(int ptrID, void *optimParamsArg, size_t optimParamsSizeArg)
{
    optimParamsPtr = ::operator new(optimParamsSizeArg);
    memcpy_s(optimParamsPtr, optimParamsSizeArg, optimParamsArg, optimParamsSizeArg);

    double ret_val;

    // Here is where the GSL stuff would be. But I replace that with a call to CostFn to show the error
    if (ptrID == 1)
    {
        ret_val = CostFn(optimParamsArg); // Works
    }
    else
    {
        ret_val = CostFn(optimParamsPtr); // Doesn't work
    }
    return ret_val;
}

// Release memory used by unmanaged variables in Optimizer
void Optimizer::FreeOptimizer()
{
    if (optimParamsPtr != NULL)
    {
        delete optimParamsPtr;
    }
}

double Foo::Optimize(int ptrID)
{
    // Create and initialize params object
    Params^ paramsArg = gcnew Params;
    paramsArg->cost_scaling = 11;
    paramsArg->FooObj = this;

    // Convert Params type object to void *
    void * paramsArgVPtr = GCHandle::ToIntPtr(GCHandle::Alloc(paramsArg)).ToPointer();
    size_t paramsArgSize = sizeof(paramsArg); // size of memory block in bytes pointed to by void pointer

    double result = 0;
    // Initialize optimizer
    result = fooOptimizer->InitOptimizer(ptrID, paramsArgVPtr, paramsArgSize);
    // Here is where the loop that does the optimization will be. Removed from this example for simplicity.
    return result;
}

int main()
{
    Foo Foo1(2);
    std::cout << Foo1.Optimize(1) << endl; // Use orig void * arg in line 81 and it works 
    std::cout << Foo1.Optimize(2) << endl; // Use memcpy_s-ed new void * public member of Optimizer in line 85 and it doesn't work
}

Just to reiterate I need to copy the params to a member in the optimizer because the optimizer will run all through the lifetime of the Foo object. So it needs to exist as long as the Optimizer object exist and not just in the scope of Foo::Optimize()

/clr support need to be selected in project properties for the code to compile. Running on an x64 solution platform.

Update 1: While trying to debug this, I got suspicious of the way I get the size of paramsArg at line 109. Looks like I am getting the size of paramsArg as size of int cost_scaling plus size of the memory storing the address to FooObj instead of the size of memory storing FooObj itself. I realized this after stumbling across this answer to another post. I confirmed this by checking the value of paramsArg after adding some new dummy double members to Foo class. As expected the value of paramsArg doesn't change. I suppose this explains why I get the error. A solution would be to write code to correctly calculate the size of a Foo class object and set that to paramsArg instead of using sizeof. But that is turning out to be too complicated and probably another question in itself. For example, how to get size of a ref class object? Anyways hopefully someone will find this helpful.