Qual è il modo migliore per inserire una struttura c in un NSArray?

Qual è il modo usuale per memorizzare le strutture C in un NSArray? Vantaggi, svantaggi, gestione della memoria?

In particolare, qual è la differenza tra valueWithBytese valueWithPointer - allevato da justin e pesce gatto di seguito.

Ecco un collegamento alla discussione di Apple valueWithBytes:objCType:per i futuri lettori ...

Per un po 'di pensiero laterale e per guardare più alle prestazioni, Evgen ha sollevato il problema dell'uso STL::vectorin C ++ .

(Ciò solleva una questione interessante: esiste una libreria c veloce, non diversa STL::vectorma molto più leggera, che consente la minima "gestione ordinata degli array" ...?)

Quindi la domanda originale ...

Per esempio:

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

Quindi: qual è il modo normale, migliore, idiomatico per memorizzare la propria struttura in quel modo in un NSArray, e come gestisci la memoria in quel linguaggio?

Si prega di notare che sto cercando specificamente il solito idioma per memorizzare gli struct. Naturalmente, si potrebbe evitare il problema creando una nuova piccola classe. Tuttavia voglio sapere come è il solito idioma per mettere effettivamente le strutture in un array, grazie.

A proposito, ecco l'approccio NSData che è forse? non migliore ...

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];

A proposito come punto di riferimento e grazie a Jarret Hardie, ecco come archiviare CGPointse simili in un NSArray:

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

(vedi Come posso aggiungere oggetti CGPoint a un NSArray in modo semplice? )

NSValue non supporta solo le strutture CoreGraphics, puoi usarlo anche per le tue. Consiglierei di farlo, poiché la classe è probabilmente più leggera rispetto NSDataa strutture di dati semplici.

Usa semplicemente un'espressione come la seguente:

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

E per recuperare il valore:

Megapoint p;
[value getValue:&p];

Suggerirei di attenersi al NSValuepercorso, ma se si desidera davvero memorizzare semplici structtipi di dati nel proprio NSArray (e altri oggetti di raccolta in Cocoa), è possibile farlo, anche se indirettamente, utilizzando Core Foundation e bridging senza pedaggio .

CFArrayRef(e la sua controparte mutevole CFMutableArrayRef) offrono allo sviluppatore maggiore flessibilità durante la creazione di un oggetto array. Vedere il quarto argomento dell'inizializzatore designato:

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

Ciò consente di richiedere che l' CFArrayRefoggetto utilizzi le routine di gestione della memoria di Core Foundation, nessuna o addirittura le proprie routine di gestione della memoria.

Esempio obbligatorio:

// 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];

L'esempio sopra ignora completamente i problemi relativi alla gestione della memoria. La struttura myStructviene creata sullo stack e quindi viene distrutta quando la funzione termina: l'array conterrà un puntatore a un oggetto che non è più lì. Puoi aggirare questo problema usando le tue routine di gestione della memoria - ecco perché l'opzione ti viene fornita - ma poi devi fare il duro lavoro del conteggio dei riferimenti, dell'allocazione della memoria, della deallocazione e così via.

Non consiglierei questa soluzione, ma la terrò qui nel caso interessasse qualcun altro. :-)

L'utilizzo della struttura allocata nell'heap (al posto dello stack) è illustrato qui:

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];

Un metodo simile per aggiungere c struct consiste nel memorizzare il puntatore e nel de-referenziare il puntatore in questo modo;

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];

se ti senti nerd o hai davvero molte classi da creare: a volte è utile costruire dinamicamente una classe objc (ref :) class_addIvar. in questo modo, puoi creare classi objc arbitrarie da tipi arbitrari. puoi specificare campo per campo, o semplicemente passare le informazioni della struttura (ma questo sta praticamente replicando NSData). a volte utile, ma probabilmente più di un "fatto divertente" per la maggior parte dei lettori.

Come lo applicherei qui?

puoi chiamare class_addIvar e aggiungere una variabile di istanza Megapoint a una nuova classe, oppure puoi sintetizzare una variante objc della classe Megapoint in fase di runtime (ad esempio, una variabile di istanza per ogni campo di Megapoint).

il primo è equivalente alla classe objc compilata:

@interface MONMegapoint { Megapoint megapoint; } @end

quest'ultima è equivalente alla classe objc compilata:

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

dopo aver aggiunto gli ivars, puoi aggiungere / sintetizzare metodi.

per leggere i valori memorizzati sull'estremità ricevente, utilizzare i metodi sintetizzati object_getInstanceVariable, o valueForKey:(che spesso convertirà queste variabili di istanza scalari in rappresentazioni NSNumber o NSValue).

btw: tutte le risposte che hai ricevuto sono utili, alcune sono migliori / peggiori / non valide a seconda del contesto / scenario. esigenze specifiche di memoria, velocità, facilità di manutenzione, facilità di trasferimento o archiviazione, ecc. determineranno quale sia la migliore per un determinato caso ... ma non esiste una soluzione "perfetta" che sia ideale sotto ogni aspetto. non esiste un "modo migliore per mettere una struttura c in un NSArray", ma solo un "modo migliore per mettere una struttura c in un NSArray per uno scenario, un caso o un insieme di requisiti specifici ", che avresti specificare.

inoltre, NSArray è un'interfaccia di array generalmente riutilizzabile per tipi di dimensioni puntatore (o più piccoli), ma ci sono altri contenitori che sono più adatti per le strutture c per molte ragioni (std :: vector è una scelta tipica per le strutture c).

sarebbe meglio usare il serializzatore objc dei poveri se condividi questi dati su più abis / architetture:

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;
/* ... */

... soprattutto se la struttura può cambiare nel tempo (o dalla piattaforma mirata). non è veloce come le altre opzioni, ma è meno probabile che si rompa in alcune condizioni (che non hai specificato come importanti o meno).

se la rappresentazione serializzata non esce dal processo, allora dimensione / ordine / allineamento di strutture arbitrarie non dovrebbero cambiare e ci sono opzioni che sono più semplici e veloci.

in entrambi i casi, stai già aggiungendo un oggetto ref-counted (rispetto a NSData, NSValue) quindi ... creare una classe objc che contiene Megapoint è la risposta giusta in molti casi.

Ti suggerisco di usare std :: vector o std :: list per i tipi C / C ++, perché all'inizio è solo più veloce di NSArray, e in secondo luogo se non ci sarà abbastanza velocità per te, puoi sempre crearne uno tuo allocatori per contenitori STL e renderli ancora più veloci. Tutti i moderni motori di gioco, fisica e audio per dispositivi mobili utilizzano contenitori STL per memorizzare i dati interni. Solo perché sono davvero veloci.

Se non è per te - ci sono buone risposte da parte di ragazzi su NSValue - penso che sia più accettabile.

Invece di provare a mettere c struct in un NSArray, puoi metterli in un NSData o NSMutableData come array ac di struct. Per accedervi fareste

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

o per impostare quindi

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

Mentre l'utilizzo di un NSValue funziona bene per l'archiviazione di strutture come un oggetto Obj-C, non è possibile codificare un NSValue contenente una struttura con NSArchiver / NSKeyedArchiver. Invece, devi codificare i singoli membri della struttura ...

Consulta la Guida alla programmazione di archivi e serializzazioni di Apple> Strutture e campi di bit

Per la tua struttura puoi aggiungere un attributo objc_boxable e utilizzare la @()sintassi per inserire la tua struttura nell'istanza NSValue senza chiamare 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)];

Un oggetto Obj C è solo una struttura C con alcuni elementi aggiunti. Quindi crea una classe personalizzata e avrai il tipo di struttura C richiesta da un NSArray. Qualsiasi struttura C che non ha la cruft extra che un NSObject include nella sua struttura C sarà indigeribile per un NSArray.

L'utilizzo di NSData come wrapper potrebbe memorizzare solo una copia delle strutture e non le strutture originali, se questo fa la differenza per te.

È possibile utilizzare classi NSObject diverse dalle C-Structures per memorizzare le informazioni. E puoi facilmente memorizzare quell'NSObject in NSArray.