Was ist der beste Weg, um eine c-Struktur in ein NSArray einzufügen?

Was ist der übliche Weg, um C-Strukturen in einem zu speichern NSArray? Vor- und Nachteile, Speicherhandhabung?

Insbesondere, was ist der Unterschied zwischen valueWithBytesund valueWithPointer - von Justin und Wels unten aufgezogen.

Hier ist ein Link zu Apples Diskussion valueWithBytes:objCType:für zukünftige Leser ...

Für ein wenig Querdenken und mehr Blick auf die Leistung hat Evgen das Problem der Verwendung STL::vectorin C ++ angesprochen .

(Das wirft ein interessantes Problem auf: Gibt es eine schnelle c-Bibliothek, die nicht anders, STL::vectoraber viel leichter ist und die minimale "ordentliche Handhabung von Arrays" ermöglicht ...?)

Also die ursprüngliche Frage ...

Beispielsweise:

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

Also: Was ist die normale, beste und idiomatische Art, die eigene Struktur so in einem zu speichern NSArray, und wie geht man mit dem Gedächtnis in dieser Sprache um?

Bitte beachten Sie, dass ich speziell nach der üblichen Sprache zum Speichern von Strukturen suche. Natürlich könnte man das Problem vermeiden, indem man eine neue kleine Klasse bildet. Ich möchte jedoch wissen, wie die übliche Redewendung zum tatsächlichen Einfügen von Strukturen in ein Array funktioniert, danke.

Übrigens ist hier der NSData-Ansatz, der vielleicht ist? nicht am besten ...

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

Übrigens als Referenz und dank Jarret Hardie, hier ist, wie man CGPointsund ähnliches in einem NSArray:

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

(Siehe Wie kann ich CGPoint-Objekte auf einfache Weise zu einem NSArray hinzufügen? )

NSValue unterstützt nicht nur CoreGraphics-Strukturen, sondern kann auch für eigene Zwecke verwendet werden. Ich würde dies empfehlen, da die Klasse wahrscheinlich leichter ist als NSDatafür einfache Datenstrukturen.

Verwenden Sie einfach einen Ausdruck wie den folgenden:

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

Und um den Wert wieder herauszuholen:

Megapoint p;
[value getValue:&p];

Ich würde vorschlagen, dass Sie sich an die NSValueRoute halten, aber wenn Sie wirklich einfache structDatentypen in Ihrem NSArray (und anderen Sammlungsobjekten in Cocoa) speichern möchten , können Sie dies tun - wenn auch indirekt mithilfe von Core Foundation und gebührenfreiem Bridging .

CFArrayRef(und sein veränderliches Gegenstück CFMutableArrayRef) bieten dem Entwickler mehr Flexibilität beim Erstellen eines Array-Objekts. Siehe das vierte Argument des bezeichneten Initialisierers:

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

Auf diese Weise können Sie anfordern, dass das CFArrayRefObjekt die Speicherverwaltungsroutinen von Core Foundation verwendet, überhaupt keine oder sogar Ihre eigenen Speicherverwaltungsroutinen.

Obligatorisches Beispiel:

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

Das obige Beispiel ignoriert die Probleme in Bezug auf die Speicherverwaltung vollständig. Die Struktur myStructwird auf dem Stapel erstellt und daher beim Beenden der Funktion zerstört. Das Array enthält einen Zeiger auf ein Objekt, das nicht mehr vorhanden ist. Sie können dies umgehen, indem Sie Ihre eigenen Speicherverwaltungsroutinen verwenden - daher wird Ihnen die Option zur Verfügung gestellt -, aber dann müssen Sie die harte Arbeit des Referenzzählens, Zuweisen von Speicher, Freigeben von Speicher usw. erledigen.

Ich würde diese Lösung nicht empfehlen, werde sie aber hier aufbewahren, falls sie für andere von Interesse ist. :-)

Die Verwendung Ihrer auf dem Heap zugewiesenen Struktur (anstelle des Stapels) wird hier demonstriert:

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

Eine ähnliche Methode zum Hinzufügen von c struct besteht darin, den Zeiger zu speichern und den Zeiger so zu de-referenzieren.

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

Wenn Sie sich nerdig fühlen oder wirklich viele Klassen erstellen müssen: Es ist gelegentlich nützlich, eine Objektklasse dynamisch zu erstellen (ref :) class_addIvar. Auf diese Weise können Sie beliebige Objektklassen aus beliebigen Typen erstellen. Sie können Feld für Feld angeben oder einfach die Informationen der Struktur übergeben (dies repliziert jedoch praktisch NSData). manchmal nützlich, aber für die meisten Leser wahrscheinlich eher eine "lustige Tatsache".

Wie würde ich das hier anwenden?

Sie können class_addIvar aufrufen und einer neuen Klasse eine Megapoint-Instanzvariable hinzufügen, oder Sie können zur Laufzeit eine objc-Variante der Megapoint-Klasse synthetisieren (z. B. eine Instanzvariable für jedes Feld von Megapoint).

Ersteres entspricht der kompilierten objc-Klasse:

@interface MONMegapoint { Megapoint megapoint; } @end

Letzteres entspricht der kompilierten objc-Klasse:

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

Nachdem Sie die Ivars hinzugefügt haben, können Sie Methoden hinzufügen / synthetisieren.

Verwenden Sie zum Lesen der gespeicherten Werte auf der Empfangsseite Ihre synthetisierten Methoden object_getInstanceVariableoder valueForKey:(die diese skalaren Instanzvariablen häufig in NSNumber- oder NSValue-Darstellungen konvertieren).

Übrigens: Alle Antworten, die Sie erhalten haben, sind nützlich, einige sind je nach Kontext / Szenario besser / schlechter / ungültig. Spezifische Anforderungen in Bezug auf Speicher, Geschwindigkeit, einfache Wartung, einfache Übertragung oder Archivierung usw. bestimmen, welche für einen bestimmten Fall am besten geeignet sind. Es gibt jedoch keine „perfekte“ Lösung, die in jeder Hinsicht ideal ist. Es gibt keine "beste Möglichkeit, eine C-Struktur in ein NSArray einzufügen", sondern nur eine "beste Möglichkeit, eine C-Struktur in ein NSArray für ein bestimmtes Szenario, einen bestimmten Fall oder eine Reihe von Anforderungen einzufügen " - die Sie hätten konkretisieren.

Darüber hinaus ist NSArray eine allgemein wiederverwendbare Array-Schnittstelle für Zeigergrößen (oder kleinere), es gibt jedoch auch andere Container, die aus vielen Gründen besser für c-Strukturen geeignet sind (std :: vector ist eine typische Wahl für c-Strukturen).

Es ist am besten, den Objekt-Serializer des armen Mannes zu verwenden, wenn Sie diese Daten über mehrere Abis / Architekturen hinweg teilen:

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

... insbesondere wenn sich die Struktur im Laufe der Zeit ändern kann (oder durch eine gezielte Plattform). Es ist nicht so schnell wie andere Optionen, aber es ist weniger wahrscheinlich, dass es unter bestimmten Bedingungen (die Sie nicht als wichtig angegeben haben oder nicht) nicht funktioniert.

Wenn die serialisierte Darstellung den Prozess nicht beendet, sollte sich Größe / Reihenfolge / Ausrichtung beliebiger Strukturen nicht ändern, und es gibt Optionen, die einfacher und schneller sind.

In beiden Fällen fügen Sie bereits ein neu gezähltes Objekt hinzu (im Vergleich zu NSData, NSValue). In vielen Fällen ist es die richtige Antwort, eine objc-Klasse zu erstellen, die Megapoint enthält.

Ich empfehle Ihnen, std :: vector oder std :: list für C / C ++ - Typen zu verwenden, da es zunächst nur schneller als NSArray ist und zweitens, wenn es nicht genug Geschwindigkeit für Sie gibt, können Sie immer Ihre eigene erstellen Allokatoren für STL-Container und machen sie noch schneller. Alle modernen mobilen Spiel-, Physik- und Audio-Engines verwenden STL-Container zum Speichern interner Daten. Nur weil sie wirklich schnell sind.

Wenn es nicht für dich ist - es gibt gute Antworten von Leuten über NSValue - denke ich, dass es am akzeptabelsten ist.

Anstatt zu versuchen, c struct in ein NSArray einzufügen, können Sie sie als ac-Array von Strukturen in NSData oder NSMutableData einfügen. Um auf sie zuzugreifen, würden Sie das tun

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

oder dann einstellen

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

Während die Verwendung eines NSValue zum Speichern von Strukturen als Obj-C-Objekt einwandfrei funktioniert, können Sie einen NSValue, der eine Struktur enthält, nicht mit NSArchiver / NSKeyedArchiver codieren. Stattdessen müssen Sie einzelne Strukturelemente codieren ...

Siehe Apples Programmierhandbuch für Archive und Serialisierungen> Strukturen und Bitfelder

Für Ihre Struktur können Sie ein Attribut hinzufügen objc_boxableund mithilfe der @()Syntax Ihre Struktur in eine NSValue-Instanz einfügen, ohne Folgendes aufzurufen 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)];

Ein Obj C-Objekt ist nur eine C-Struktur mit einigen hinzugefügten Elementen. Erstellen Sie einfach eine benutzerdefinierte Klasse, und Sie erhalten den Typ der C-Struktur, den ein NSArray benötigt. Jede C-Struktur, die nicht die zusätzliche Cruft hat, die ein NSObject in seiner C-Struktur enthält, ist für ein NSArray unverdaulich.

Wenn Sie NSData als Wrapper verwenden, wird möglicherweise nur eine Kopie der Strukturen und nicht der ursprünglichen Strukturen gespeichert, wenn dies für Sie einen Unterschied darstellt.

Sie können andere NSObject-Klassen als die C-Strukturen zum Speichern von Informationen verwenden. Und Sie können dieses NSObject einfach in NSArray speichern.