NSArray'e bir c-struct yerleştirmenin en iyi yolu nedir?

C yapılarını depolamanın genel yolu nedir NSArray? Avantajlar, dezavantajlar, bellek kullanımı?

Özellikle, justin ve aşağıdaki yayın balığı tarafından yetiştirilen valueWithBytesve arasındaki fark nedir valueWithPointer?

İşte Apple'ın valueWithBytes:objCType:gelecekteki okuyucular için tartışmasına bir bağlantı ...

Bazı yanal düşünme ve daha performans bakarak için Evgen kullanarak konusu gündeme getiriliyor STL::vectoriçinde C ++ .

(Bu ilginç bir sorunu ortaya çıkarıyor: hızlı bir c kütüphanesi var mı, farklı olmayan STL::vectorama çok daha hafif, minimum "dizilerin düzenli işlenmesine" izin veren ...?)

Yani asıl soru ...

Örneğin:

typedef struct _Megapoint {
    float   w,x,y,z;
} Megapoint;

Öyleyse: kişinin kendi yapısını böyle bir şekilde saklamanın normal, en iyi, deyimsel yolu NSArraynedir ve bu deyimdeki belleği nasıl ele alırsınız?

Lütfen özellikle yapıları depolamak için her zamanki deyimi aradığımı unutmayın. Elbette, yeni bir küçük sınıf oluşturarak bu sorunu önleyebilirsiniz. Bununla birlikte, yapıları bir diziye koymak için her zamanki deyimin nasıl olduğunu bilmek istiyorum, teşekkürler.

BTW işte NSData yaklaşımı, belki de nedir? en iyisi değil ...

Megapoint p;
NSArray *a = [NSArray arrayWithObjects:
    [NSData dataWithBytes:&p length:sizeof(Megapoint)],
    [NSData dataWithBytes:&p length:sizeof(Megapoint)],
    [NSData dataWithBytes:&p length:sizeof(Megapoint)],
        nil];

BTW bir referans noktası olarak ve Jarret Hardie sayesinde, işte burada nasıl saklanacağı CGPointsve benzerleri NSArray:

NSArray *points = [NSArray arrayWithObjects:
        [NSValue valueWithCGPoint:CGPointMake(6.9, 6.9)],
        [NSValue valueWithCGPoint:CGPointMake(6.9, 6.9)],
        nil];

( bkz.CGPoint nesnelerini bir NSArray'e kolay yoldan nasıl ekleyebilirim? )

NSValue yalnızca CoreGraphics yapılarını desteklemez - kendi başınıza da kullanabilirsiniz. Sınıf muhtemelen NSDatabasit veri yapıları için olduğundan daha hafif olduğu için bunu yapmanızı tavsiye ederim .

Aşağıdaki gibi bir ifade kullanın:

[NSValue valueWithBytes:&p objCType:@encode(Megapoint)];

Ve değeri geri almak için:

Megapoint p;
[value getValue:&p];

NSValueRotaya sadık kalmanızı öneririm , ancak structNSArray'ınızda (ve Cocoa'daki diğer koleksiyon nesnelerinde) düz 'eski veri türlerini gerçekten depolamak istiyorsanız, bunu dolaylı da olsa Core Foundation ve ücretsiz köprüleme kullanarak yapabilirsiniz. .

CFArrayRef(ve onun değiştirilebilir karşılığı CFMutableArrayRef), geliştiriciye bir dizi nesnesi oluştururken daha fazla esneklik sağlar. Atanan başlatıcının dördüncü argümanına bakın:

CFArrayRef CFArrayCreate (
    CFAllocatorRef allocator,
    const void **values,
    CFIndex numValues,
    const CFArrayCallBacks *callBacks
);

Bu, CFArrayRefnesnenin Core Foundation'ın bellek yönetimi yordamlarını kullanmasını istemenize olanak tanır , hiçbiri veya kendi bellek yönetimi yordamlarınızı bile .

Zorunlu örnek:

// One would pass &kCFTypeArrayCallBacks (in lieu of NULL) if using CF types.
CFMutableArrayRef arrayRef = CFArrayCreateMutable(kCFAllocatorDefault, 0, NULL);
NSMutableArray *array = (NSMutableArray *)arrayRef;

struct {int member;} myStruct = {.member = 42};
// Casting to "id" to avoid compiler warning
[array addObject:(id)&myStruct];

// Hurray!
struct {int member;} *mySameStruct = [array objectAtIndex:0];

Yukarıdaki örnek, bellek yönetimi ile ilgili sorunları tamamen göz ardı etmektedir. Yapı myStructyığın üzerinde yaratılır ve dolayısıyla işlev sona erdiğinde yok edilir - dizi artık orada olmayan bir nesneye bir işaretçi içerecektir. Kendi bellek yönetimi rutinlerinizi kullanarak bu sorunu çözebilirsiniz - bu nedenle bu seçenek size sağlanmıştır - ancak daha sonra referans sayma, bellek ayırma, ayırma vb. Gibi zor işleri yapmanız gerekir.

Bu çözümü tavsiye etmem, ancak başkalarının ilgisini çekmesi durumunda burada saklayacağım. :-)

Yapınızı yığın üzerinde tahsis edildiği gibi kullanmak (yığın yerine) burada gösterilmektedir:

typedef struct {
    float w, x, y, z;
} Megapoint;

// One would pass &kCFTypeArrayCallBacks (in lieu of NULL) if using CF types.
CFMutableArrayRef arrayRef = CFArrayCreateMutable(kCFAllocatorDefault, 0, NULL);
NSMutableArray *array = (NSMutableArray *)arrayRef;

Megapoint *myPoint = malloc(sizeof(Megapoint);
myPoint->w = 42.0f;
// set ivars as desired..

// Casting to "id" to avoid compiler warning
[array addObject:(id)myPoint];

// Hurray!
Megapoint *mySamePoint = [array objectAtIndex:0];

C struct eklemenin benzer bir yöntemi, işaretçiyi depolamak ve bu şekilde işaretçinin referansını kaldırmaktır;

typedef struct BSTNode
{
    int data;
    struct BSTNode *leftNode;
    struct BSTNode *rightNode;
}BSTNode;

BSTNode *rootNode;

//declaring a NSMutableArray
@property(nonatomic)NSMutableArray *queues;

//storing the pointer in the array
[self.queues addObject:[NSValue value:&rootNode withObjCType:@encode(BSTNode*)]];

//getting the value
BSTNode *frontNode =[[self.queues objectAtIndex:0] pointerValue];

Eğer kendinizi inek gibi hissediyorsanız veya gerçekten oluşturacak çok sayıda sınıfınız varsa: dinamik olarak bir objc sınıfı (ref:) oluşturmak bazen yararlıdır class_addIvar. bu şekilde, rastgele türlerden rastgele nesne sınıfları oluşturabilirsiniz. alanı alana göre belirtebilir veya yapının bilgilerini iletebilirsiniz (ancak bu pratik olarak NSData'yı kopyalar). bazen yararlıdır, ancak muhtemelen çoğu okuyucu için daha 'eğlenceli bir gerçek'.

Bunu buraya nasıl uygularım?

class_addIvar'ı çağırabilir ve yeni bir sınıfa bir Megapoint örnek değişkeni ekleyebilir veya çalışma zamanında Megapoint sınıfının bir objc varyantını sentezleyebilirsiniz (örneğin, Megapoint'in her alanı için bir örnek değişkeni).

ilki, derlenen objc sınıfına eşdeğerdir:

@interface MONMegapoint { Megapoint megapoint; } @end

ikincisi, derlenen objc sınıfına eşdeğerdir:

@interface MONMegapoint { float w,x,y,z; } @end

ivarları ekledikten sonra yöntemler ekleyebilir / sentezleyebilirsiniz.

alıcı uçta saklanan değerleri okumak için, sentezlenmiş yöntemlerinizi kullanın object_getInstanceVariableveya valueForKey:(bu, bu skaler örnek değişkenlerini genellikle NSNumber veya NSValue gösterimlerine dönüştürür).

btw: Aldığınız tüm cevaplar yararlı, bazıları bağlama / senaryoya bağlı olarak daha iyi / daha kötü / geçersiz. Bellek, hız, bakım kolaylığı, aktarım veya arşivleme kolaylığı vb. ile ilgili özel ihtiyaçlar, belirli bir durum için hangisinin en iyi olduğunu belirleyecektir ... ancak her açıdan ideal olan 'mükemmel' bir çözüm yoktur. 'NSArray'e bir c-struct yerleştirmenin en iyi yolu' yoktur, sadece ' belirli bir senaryo, durum veya gereksinimler kümesi için bir NSArray'e c-struct yerleştirmenin en iyi yolu ' yoktur - belirtmek için.

ayrıca NSArray, işaretçi boyutlu (veya daha küçük) türler için genel olarak yeniden kullanılabilir bir dizi arabirimidir, ancak birçok nedenden ötürü c-yapıları için daha uygun olan başka kaplar da vardır (std :: vektör, c-yapıları için tipik bir seçimdir).

Bu verileri birden çok abis / mimaride paylaşıyorsanız, fakir adamın objc serileştiricisini kullanmak en iyisidir:

Megapoint mpt = /* ... */;
NSMutableDictionary * d = [NSMutableDictionary new];
assert(d);

/* optional, for your runtime/deserialization sanity-checks */
[d setValue:@"Megapoint" forKey:@"Type-Identifier"];

[d setValue:[NSNumber numberWithFloat:mpt.w] forKey:@"w"];
[d setValue:[NSNumber numberWithFloat:mpt.x] forKey:@"x"];
[d setValue:[NSNumber numberWithFloat:mpt.y] forKey:@"y"];
[d setValue:[NSNumber numberWithFloat:mpt.z] forKey:@"z"];

NSArray *a = [NSArray arrayWithObject:d];
[d release], d = 0;
/* ... */

... özellikle yapı zamanla (veya hedeflenen platform tarafından) değişebiliyorsa. diğer seçenekler kadar hızlı değildir, ancak bazı koşullarda (önemli veya önemli olmadığını belirtmediğiniz) bozulma olasılığı daha düşüktür.

serileştirilmiş gösterim süreçten çıkmazsa, rastgele yapıların boyutu / sırası / hizalaması değişmemelidir ve daha basit ve daha hızlı seçenekler vardır.

Her iki durumda da, ref-sayılan bir nesneyi zaten ekliyorsunuz (NSData, NSValue ile karşılaştırıldığında), bu nedenle ... Megapoint'i tutan bir objc sınıfı oluşturmak çoğu durumda doğru cevaptır.

C / C ++ türleri için std :: vector veya std :: list kullanmanızı öneririm, çünkü ilk başta NSArray'den daha hızlıdır ve ikinci olarak sizin için yeterli hız olmayacaksa - her zaman kendinizinkini oluşturabilirsiniz STL kaplar için ayırıcılar ve daha hızlı hale getirin. Tüm modern mobil Oyun, Fizik ve Ses motorları, dahili verileri depolamak için STL kapları kullanır. Sırf gerçekten hızlı oldukları için.

Sizin için değilse - adamlardan NSValue hakkında iyi yanıtlar var - bence en çok kabul edilebilir.

NSArray'e c struct koymaya çalışmak yerine, onları bir NSData veya NSMutableData içine bir yapı dizisi olarak yerleştirebilirsiniz. Onlara erişmek için yaparsın

const struct MyStruct    * theStruct = (const struct MyStruct*)[myData bytes];
int                      value = theStruct[2].integerNumber;

veya ayarlamak için

struct MyStruct    * theStruct = (struct MyStruct*)[myData mutableBytes];
theStruct[2].integerNumber = 10;

Bir NSValue kullanmak, yapıları bir Obj-C nesnesi olarak depolamak için iyi sonuç verirken, NSArchiver / NSKeyedArchiver ile bir yapı içeren bir NSValue'yu kodlayamazsınız. Bunun yerine, bireysel yapı üyelerini kodlamanız gerekir ...

Bkz Apple'ın Arşivler ve Serializations Rehberi> Yapıları ve Bit Alanları Programlama

Yapınız için, yapınızı NSValue örneğine çağırmadan bir öznitelik ekleyebilir objc_boxableve @()sözdizimini kullanabilirsiniz valueWithBytes:objCType::

typedef struct __attribute__((objc_boxable)) _Megapoint {
    float   w,x,y,z;
} Megapoint;

NSMutableArray<NSValue*>* points = [[NSMutableArray alloc] initWithCapacity:10];
for (int i = 0; i < 10; i+= 1) {
    Megapoint mp1 = {i + 1.0, i + 2.0, i + 3.0, i + 4.0};
    [points addObject:@(mp1)];//@(mp1) creates NSValue*
}

Megapoint unarchivedPoint;
[[points lastObject] getValue:&unarchivedPoint];
//or
// [[points lastObject] getValue:&unarchivedPoint size:sizeof(Megapoint)];

Bir Obj C nesnesi, bazı eklenmiş öğeler içeren bir C yapısıdır. Yani sadece özel bir sınıf oluşturun ve NSArray'in gerektirdiği C yapısı türüne sahip olacaksınız. Bir NSObject'in kendi C yapısı içinde içerdiği fazladan ufaklığa sahip olmayan herhangi bir C yapısı, bir NSArray tarafından sindirilemez.

NSData'yı bir sarmalayıcı olarak kullanmak, sizin için bir fark yaratıyorsa orijinal yapıların değil, yalnızca yapıların bir kopyasını depoluyor olabilir.

Bilgileri depolamak için C-Structures dışındaki NSObject sınıflarını kullanabilirsiniz. Ve bu NSObject'i kolayca NSArray'de saklayabilirsiniz.