Как правильно вызвать CFBinaryHeapGetValues() и проанализировать полученный массив C в Swift?

В вашем коде:

CFBinaryHeapAddValue(bh, fooPointer)

Вы проходите UnsafeMutablePointer<CountedColor> два раза.

(Количество элементов влияет на многие части.)

Итак, при вызове CFBinaryHeapGetValues(bh, elementPtr) вам нужно зарезервировать область для C-массива, которая может содержать два UnsafeMutablePointer<CountedColor>.

Вы должны написать это как:

var elementPtr = UnsafeMutablePointer<UnsafeRawPointer?>.allocate(capacity: 2)  //<- You need to allocate a region for two elements
elementPtr.initialize(to: nil, count: 2) //<- The content is overwritten, initial values can be nil
CFBinaryHeapGetValues(bh, elementPtr)

И этот код:

var returnedValues: UnsafePointer<[CountedColor]> = (elementPtr.pointee?.assumingMemoryBound(to: [CountedColor].self))!

Как я писал выше, результат, хранящийся в области, указанной elementPtr, является UnsafeMutablePointer<CountedColor>s, а не UnsafePointer<[CountedColor]>.

elementPtr.pointee извлекает первое UnsafeMutablePointer<CountedColor>, поэтому ваши два оператора print работают, но это не означает, что returnedValues вашего кода содержит то, что вы ожидаете.

Одним из хороших способов обработки C-массивов является создание файла UnsafeBufferPointer.

let returnedValues = UnsafeBufferPointer(start: elementPtr, count: 2)

UnsafeBufferPointer работает как тип коллекции, поэтому вы можете легко преобразовать его в Array.

let values = returnedValues.map{$0!.load(as: CountedColor.self)}

И, пожалуйста, не забудьте deinitialize и deallocate регионы allocateed.

Чтобы сделать это, вам нужно сохранить все выделенные указатели и их количество. Итак, вам может потребоваться изменить часть вашего кода, например:

var fooPointer : UnsafeMutablePointer<CountedColor>!
fooPointer = UnsafeMutablePointer<CountedColor>.allocate(capacity: 1)
fooPointer.initialize(to: CountedColor(color: UIColor.blue, colorCount: 72))
CFBinaryHeapAddValue(bh, fooPointer)
var barPointer : UnsafeMutablePointer<CountedColor>!
barPointer = UnsafeMutablePointer<CountedColor>.allocate(capacity: 1)
barPointer.initialize(to: CountedColor(color: UIColor.red, colorCount: 99))
CFBinaryHeapAddValue(bh, barPointer)

Затем, после завершения использования вашей CFBinaryHeap (bh)...

elementPtr.deinitialize(count: 2)
elementPtr.deallocate(capacity: 2)
barPointer.deinitialize()
barPointer.deallocate(capacity: 1)
fooPointer.deinitialize()
fooPointer.deallocate(capacity: 1)

Вы можете добавить произвольное количество CountedColors в CFBinaryHeap, в этом случае вы можете написать что-то вроде этого:

let colors = [
    CountedColor(color: UIColor.blue, colorCount: 72),
    CountedColor(color: UIColor.red, colorCount: 99),
    //...
]
var fooPointer : UnsafeMutablePointer<CountedColor>!
fooPointer = UnsafeMutablePointer<CountedColor>.allocate(capacity: colors.count)
fooPointer.initialize(from: colors)
for i in colors.indices {
    CFBinaryHeapAddValue(bh, fooPointer+i)
}

(Возможно, вам придется изменить все count: или capacity:, имеющие 2 в моем коде, на colors.count.)

А потом..

elementPtr.deinitialize(count: colors.count)
elementPtr.deallocate(capacity: colors.count)
fooPointer.deinitialize(count: colors.count)
fooPointer.deallocate(capacity: colors.count)

В любом случае, сопоставьте initialize и deinitialize, allocate и deallocate.

Вы можете найти некоторые полезные типы в стандартной библиотеке Swift для улучшения кода, но слишком много вещей за один раз может быть плохой привычкой для изучения...