xptr | Manipulating External Pointer | Object Storage library

I think that you already have enough information to understand that concept. You know that 2D array are really stored in linear address space.

The mismatch is caused by the fact that you allocated more space in a table row than you used. When you try to get the values you should omit that unused space. That's why the fix multiplies the current row by the row size, to jump to the first element of the row you are aiming to read from.

Since you use a shared_ptr, you have two references to both objects. These are x and x2, and the shared_ptrs inside vector v.

When you erase(), the destructor of shared_ptr is called, and the reference count is decremented, but still 1. Therefore object X still exists. After leaving the scope of main(), the count is decremented again. Now the count goes down to zero, and the destructor of object X is called.

Hence the output "after erase" is shown first, and only then "Destr X".

When you put x and x2 in an inner scope, you will see the expected behaviour

in main the variables xPtr and yPtr are never initialized

the assignments in point are local and without consequence out of point, if you want to modify the variables having the same name in main you can do :

We use external pointers for things that do not have already existing interfaces such as database connections or objects from other new libraries. You may be better off looking at some existing uses of XPtr (or the other external pointer variants in some other packages, there are two small ones on CRAN).

And I don't think I can think of an example directly referencing this in R. It is mostly for "wrapping" external objects to hold on to them and to pass them around for further use elsewhere. And you are correct that you need to read up a little on finalizers. I find reading Writing R Extensions, as dense as it is, to be the best source because you need to get the initial "basics" in C right first.

Yes that's perfectly reasonable and safe as long as the C/C++ code doesn't free the memory. Note that it isn't always necessary (or desirable) to use Marshal here; depending on what is, you can do this in other ways too, including:

• unsafe (cast a void* to a X*)
• Unsafe.AsRef(...) (which casts a void* to a ref X)
• new Span(...) (which creates a span of some number of X from a void*; a span is like a vector, but talking to arbitrary memory)

All of these are zero-copy approaches, meaning your C# code is then talking directly to exactly the same memory space, not a local snapshot; but if you dereference the pointer (managed or unmanged) into a non-reference local, then it will make a copy.

put the struct declarations before the function prototypes

Short answer: Not a SYCL issue ;)

Based on your edit 1, it is clear that if the lines

As mentioned in the comments, as far as the language is concerned, this is Undefined Behavior.

However, the actual chosen behavior does reveal how the innards of a typical C++ compiler works, so it can still be interesting to investigate why you got the output you did. However, It's important to remember that the following explanation is not universal. There are no hard requirement for things to work this way, and any code relying on things behaving this way is effectively broken, even if it works on all compilers you try it on.

C++ polymorphism is typically implemented using a vtable, which is basically a list of function pointers, and can be seen as a hidden member pointer in the object.

so