A modern programming language that makes developers happier.

kotlinlang

Where can I find an example of allocating an array of structs in order to pass a `CValuesRef` to the leading item + item count to a C function? I've done with things like ByteArray where I can call `refTo(0)` but I don't see an explanation or example of how to do this with a struct type.

I've done this: <https://github.com/apollographql/apollo-android/blob/aa5137599b957a9dcf2702eefbafac83d98d3158/apollo-mockserver/src/appleMain/kotlin/com/apollographql/apollo3/mockserver/Socket.kt#L51|https://github.com/apollographql/apollo-android/blob/aa5137599b957a9dcf2702eefbafa[…]appleMain/kotlin/com/apollographql/apollo3/mockserver/Socket.kt>

thanks. this will unblock me, i think, but it's far from ideal...

i'm also getting structs back from a call to a C function so i have to copy their contents into each index which is not pretty

```    val args = allocArray&lt;Thing&gt;(4)
    arg0.useContents {
      args[0].tag = tag
      args[0].u.int32 = u.int32
      args[0].u.float64 = u.float64
    }
    // etc.```

and sure I can put it behind a helper function, but it's still very awkward

But C cannot return array of structs by values, right? So it's all pointer based ?

```void myfunction(struct thing * input_output_param, int *size)```

Then you can use the same allocated array for both input + output maybe?

Maybe this can be helpful?
• <https://github.com/Durun/vst3kotlin/blob/f1082278b6c763fbebb4318c83f7aecdf501e233/vst3pluginterface/src/nativeMain/kotlin/durun/vst3kotlin/pluginterface/vst/ParameterChanges.kt#L12-L45|https://github.com/Durun/vst3kotlin/blob/f1082278b6c763fbebb4318c83f7aecdf501e233/[…]n/kotlin/durun/vst3kotlin/pluginterface/vst/ParameterChanges.kt>
• <https://github.com/Durun/vst3kotlin/blob/f1082278b6c763fbebb4318c83f7aecdf501e233/vst3cwrapper/src/main/headers/cppinterface/memory.h#L16-L24>
I have been using this as a reference for some of the lower-level KN stuff.
This person defined:
```template&lt;typename T&gt;
T *allocArray(int length) {
    auto ptr = reinterpret_cast&lt;T *&gt;(malloc(sizeof(T) * length));
    if (ptr == nullptr) {
        fprintf(stderr, "Failed to allocate array of T (length=%d).\n", length);
        return nullptr;
    }
    return ptr;
}```
And then uses it like you see in `ParameterChanges.kt` (or other places if you search for `allocArray`)

Disclaimer: I genuinely don't understand how some of the things in this repo work, but the person appears to know what they were doing

I think I cracked it
```internal inline operator fun &lt;reified T : CVariable&gt; CPointer&lt;T&gt;.set(index: Int, item: CValues&lt;T&gt;) {
  val offset = index * sizeOf&lt;T&gt;()
  item.place(interpretCPointer(rawValue + offset)!!)
}

internal inline fun &lt;reified T : CVariable&gt; NativePlacement.allocArrayOf(
  vararg items: CValues&lt;T&gt;,
): CArrayPointer&lt;T&gt; {
  val array = allocArray&lt;T&gt;(items.size)
  items.forEachIndexed { index, item -&gt;
    array[index] = item
  }
  return array
}```

it's really the first part. the second is just convenience.