Schwach NSString-variable nicht nil ist, nach der Einstellung nur mit einer starken Referenz auf nil

Ich habe ein problem mit diesem code :

__strong NSString *yourString = @"Your String"; 
__weak NSString *myString = yourString;
yourString = nil;
__unsafe_unretained NSString *theirString = myString;
NSLog(@"%p %@", yourString, yourString);
NSLog(@"%p %@", myString, myString);
NSLog(@"%p %@", theirString, theirString);

Erwarte ich, dass alle Zeiger werden nil zu dieser Zeit, aber Sie sind nicht und ich verstehe nicht, warum.
Die ersten (starken) Zeiger nil aber die anderen beiden sind nicht. Warum ist das so?

InformationsquelleAutor marcL | 2012-06-06

  1. 30

    tl; dr: Das problem ist, dass das string-literal wird nie veröffentlicht, damit Ihre schwachen Zeiger noch Punkte.

    Theorie

    Starke Variablen behalten den Wert, den Sie zeigen.

    Schwach Variablen nicht Ihren Wert behalten und, wenn der Wert freigegeben ist, können Sie Ihren Zeiger auf nil (um sicher zu sein).

    Unsicher unretained Werte (wie Sie wahrscheinlich Lesen können, durch den Namen) nicht behalten den Wert und wenn er freigegeben ist, tun Sie nichts über es, möglicherweise Hinweis auf ein schlechtes Stück Speicher

    Literale und Konstanten

    Beim erstellen einer Zeichenfolge mit @"literal string" es wird ein string-literal das niemals ändern wird. Wenn Sie verwenden Sie denselben string in vielen Orten in Ihrer Anwendung, es ist immer das gleiche Objekt. String-Literale geht nicht Weg. Mit [[NSString alloc] initWithString:@"literal string"] wird keinen Unterschied machen. Da es wird ein Zeiger auf die Zeichenkette. Es ist jedoch erwähnenswert, dass [[NSString alloc] initWithFormat:@"literal string"]; funktioniert anders und wird die Freigabe seiner string-Objekt.

    Zeile:

    __strong NSString *yourString = @"Your String";

    Erstellen Sie einen starken Zeiger auf einen string. Dadurch wird sichergestellt, dass der Wert geht nicht Weg. In Ihrem Fall ist es etwas besonderes, da der string ist ein string-literal, das technisch nicht freigegeben.

    __weak NSString *myString = yourString;

    Erstellen Sie eine schwache Zeiger auf das gleiche wie Ihre starke Zeiger. Wenn in dieser Zeit der starken Zeiger würde auf etwas anderes zeigen, den Wert, den es gerichtet ist, zu bekommen würde aufgehoben, dann wird der weak pointer ändern würde, seinen Wert, so dass Sie Punkte zu nil. Jetzt ist es noch Punkte die gleiche wie die starke Zeiger. 

    yourString = nil;

    Ihre starke Zeiger nil. Nichts weist auf den alten string, so sollte es freigesetzt werden, wenn es nicht für die Tatsache, dass es war eine literal-Zeichenfolge. Wenn Sie versucht haben, die genau die gleiche Sache mit anderen Gegenständen, die Sie selbst erstellt haben, die schwachen Variablen ändern, so dass es Punkte zu nil. Aber, da das string-literal ein literal ist und geht nicht Weg. Die schwachen variable wird immer noch auf. 

    __unsafe_unretained NSString *theirString = myString;

    Einen neuen unretained-pointer erstellt, der auf Ihre schwach-pointer, die auf das string-literal.

    NSLog(@"%p %@", yourString, yourString);
NSLog(@"%p %@", myString, myString);
NSLog(@"%p %@", theirString, theirString);

    Drucken Sie alle Ihre Saiten und verwirrt, warum der erste Wert ist nil aber die anderen beiden nicht.

    Verwandte Lesen:

    Was ist der Unterschied zwischen einer string-Konstanten und string-literalen?

    Thx Ihnen sehr für diese Erklärung, so, wenn ich das tun : __starke NSString *yourString = [[NSString alloc] initWithString:@"Dein String"]; nach dieser Variablen auf null, wird der Zeiger von myString werden null-Nein ?
    Sorry, Nein. Das wird auch auf die string-literal, das bedeutet, dass die schwachen Mauszeiger beim zeigen auf den starken Zeiger auf den string-literalen, die nicht weggeht.
    Oh, ich habe versucht initialisiert YourString mit dieser Funktion initWithUTF8String und das Ergebnis war gut. Nur die Letzte Frage, für was Grund, es ist nicht möglich, erhalten Sie das gleiche Ergebnis mit : "initWithString" ?
    Sorry, ich werde nicht in der Lage zu geben, eine gute Antwort, warum das so ist. Es ist nur die Art, wie die Dinge funktionieren. Ich kann nur vermuten, warum initWithUTF8String anders funktioniert, aber das ist nur meine Vermutungen.
    Es ist eine Implementierung detail, aber -initWithString: ist grundsätzlich die Freigabe des Objekts auf dem Sie aufgerufen wird, kopiert das argument, und das zurück kopieren. Als eine weitere Optimierung, unveränderlichen Wert oft Objekte implementieren -copy einfach ein -retain da ist es egal, ob du ein "echtes" Exemplar oder einfach nur das gleiche Objekt wieder zurück. Da das original ist unveränderlich und die Kopie ist unveränderlich, Sie wird immer die gleiche sein. Schließlich, Beibehaltung ein string-literal tut nichts, weil es permanent. Alle kombiniert, -initWithString: gegeben, ein literal gibt, das gleiche literal.

    InformationsquelleAutor David Rönnqvist

  2. 3

    David ist 100% richtig in seiner Antwort. Ich habe gerade vier explizite Beispiele für die Verwendung von GHUnit.

    Die Lebensdauer qualifier Verhalten bei Objekt-Referenzen.

    Mit NSObject als proxy-Variable für alle Objekte, die das Verhalten der Lebensdauer Qualifier ist wie erwartet.

    - (void) test_usingNSObjects
{
    NSObject *value1 = [[NSObject alloc] init];
    NSObject *value2 = [[NSObject alloc] init];
    NSObject *value3 = [[NSObject alloc] init];
    __strong NSObject *sRefToValue = value1;
    __weak NSObject *wRefToValue = value2;
    __unsafe_unretained NSObject *uRefToValue = value3;

    value1 = value2 = value3 = nil;

    GHAssertNotNil(sRefToValue,
                   @"Strong reference to the object that was originally \
                   assigned to value1.  Even though value1 was set to nil, the \
                   strong reference to the object keeps the object from being \
                   destroyed.");

    GHAssertNil(wRefToValue,
                @"Weak reference to the object that was originally assigned to \
                value2.  When value2 was set to nil, the weak reference does \
                not prevent the object from being destroyed. The weak \
                reference is also set to nil.");

    //Removing the #ifdef and #endif lines will result in a EXC_BAD_ACCESS
    //signal.  Receiving a EXC_BAD_ACCESS signal is the expected behavior for
    //that code.
#ifdef RECIEVE_EXC_BAD_ACCESS
    GHAssertNotNil(uRefToValue,
                   @"Unsafe unretained reference to the object that was \
                   originally assigned to value3.  When value3 was set to nil, \
                   the unsafe unretained reference does not prevent the object \
                   from being destroyed. The unsafe unretained reference is \
                   unaltered and the reference is invalid.  Accessing the \
                   reference will result in EXC_BAD_ACCESS signal.");
#endif

    //To avoid future EXC_BAD_ACCESS signals.
    uRefToValue = nil;
}

    Die Lebensdauer qualifier Verhalten für wörtliche NSStrings (@"etwas").

    Dies ist im Grunde das gleiche wie test_usingNSObjects, aber statt mit einem NSObject eine NSString zugeordnet ist, eine literal-Zeichenfolge verwendet. Da literal-Zeichenfolgen werden nicht zerstört wie andere Objekte, verschiedene Verhaltensweisen für __weak und __unsafe_unretained Variablen beobachtet werden.

    - (void) test_usingLiteralNSStrings
{
    NSString *value1 = @"string 1";
    NSString *value2 = @"string 2";
    NSString *value3 = @"string 3";
    __strong NSString *sRefToValue = value1;
    __weak NSString *wRefToValue = value2;
    __unsafe_unretained NSString *uRefToValue = value3;

    value1 = value2 = value3 = nil;

    GHAssertNotNil(sRefToValue,
                   @"Strong reference to the object that was originally \
                   assigned to value1.  Even though value1 was set to nil, \
                   literal strings are not destroyed.");

    GHAssertNotNil(wRefToValue,
                   @"Weak reference to the object that was originally assigned \
                   to value2.  Even though value2 was set to nil, \
                   literal strings are not destroyed so the weak reference is \
                   still valid.");

    GHAssertNotNil(uRefToValue,
                   @"Unsafe unretained reference to the object that was \
                   originally assigned to value3.  Even though value3 was set \
                   to nil, literal strings are not destroyed so the unsafe \
                   unretained reference is still valid.");
}

    Die Lebensdauer qualifier Verhalten für die nicht-wörtliche NSStrings.

    Dies ist im Grunde das gleiche wie test_usingNSObjects, aber statt mit einem NSObject eine NSString zugeordnet ist, eine nicht-wörtliche Zeichenfolge verwendet. Da die nicht-wörtliche Zeichenfolgen zerstört werden wie andere Objekte, die Verhaltensweisen sind die gleichen, wie beobachtet, in test_usingNSObjects.

    - (void) test_usingNonliteralNSStrings
{
    NSString *value1 = [[NSString alloc] initWithFormat:@"string 1"];
    NSString *value2 = [[NSString alloc] initWithFormat:@"string 2"];
    NSString *value3 = [[NSString alloc] initWithFormat:@"string 3"];
    __strong NSString *sRefToValue = value1;
    __weak NSString *wRefToValue = value2;
    __unsafe_unretained NSString *uRefToValue = value3;

    value1 = value2 = value3 = nil;

    GHAssertNotNil(sRefToValue,
                   @"Strong reference to the object that was originally \
                   assigned to value1.  Even though value1 was set to nil, the \
                   strong reference to the object keeps the object from being \
                   destroyed.");

    GHAssertNil(wRefToValue,
                @"Weak reference to the object that was originally assigned to \
                value2.  When value2 was set to nil, the weak reference does \
                not prevent the object from being destroyed. The weak \
                reference is also set to nil.");

    //Removing the #ifdef and #endif lines will result in a EXC_BAD_ACCESS
    //signal.  Receiving a EXC_BAD_ACCESS signal is the expected behavior for
    //that code.
#ifdef RECIEVE_EXC_BAD_ACCESS
    GHAssertNotNil(uRefToValue,
                   @"Unsafe unretained reference to the object that was \
                   originally assigned to value3.  When value3 was set to nil, \
                   the unsafe unretained reference does not prevent the object \
                   from being destroyed. The unsafe unretained reference is \
                   unaltered and the reference is invalid.  Accessing the \
                   reference will result in EXC_BAD_ACCESS signal.");
#endif

    //To avoid future EXC_BAD_ACCESS signals.
    uRefToValue = nil;
}

    NSString Schöpfung - die wörtliche vs. nicht-wörtliche.

    Zeigt Saiten auf unterschiedliche Art und Weise, wenn Sie literal noch nicht-wörtliche.

    - (void) test_stringCreation
{
    NSString *literalString = @"literalString";
    NSString *referenced = literalString;
    NSString *copy = [literalString copy];
    NSString *initWithString = [[NSString alloc] initWithString:literalString];
    NSString *initWithFormat = [[NSString alloc] initWithFormat:@"%@", literalString];

    //Testing that the memory addresses of referenced objects are the same.
    GHAssertEquals(literalString, @"literalString", @"literal");
    GHAssertEquals(referenced, @"literalString", @"literal");
    GHAssertEquals(copy, @"literalString", @"literal");
    GHAssertEquals(initWithString, @"literalString", @"literal");
    GHAssertNotEquals(initWithFormat, @"literalString",
                      @"nonliteral - referenced objects' memory addresses are \
                      different.");

    //Testing that the objects referenced are equal, i.e. isEqual: .
    GHAssertEqualObjects(literalString, @"literalString", nil);
    GHAssertEqualObjects(referenced, @"literalString", nil);
    GHAssertEqualObjects(copy, @"literalString", nil);
    GHAssertEqualObjects(initWithString, @"literalString", nil);
    GHAssertEqualObjects(initWithFormat, @"literalString", nil);

    //Testing that the strings referenced are the same, i.e. isEqualToString: .
    GHAssertEqualStrings(literalString, @"literalString", nil);
    GHAssertEqualStrings(referenced, @"literalString", nil);
    GHAssertEqualStrings(copy, @"literalString", nil);
    GHAssertEqualStrings(initWithString, @"literalString", nil);
    GHAssertEqualStrings(initWithFormat, @"literalString", nil);
}

    InformationsquelleAutor mmorris

  3. -2

    die schwache Eigenschaft wird nur festgelegt werden auf null nach dem autorelease-pool abgelassen wurde.

    versuchen:

    @autoreleasepool {
    _strong NSString *yourString = @"Your String"; 
    __weak NSString *myString = yourString;
    yourString = nil;
    __unsafe_unretained NSString *theirString = myString;
}

NSLog(@"%p %@", yourString, yourString);
NSLog(@"%p %@", myString, myString);
NSLog(@"%p %@", theirString, theirString);

    InformationsquelleAutor Pizzaiola Gorgonzola

Schreibe einen Kommentar