R – Does NSString stringWithCString: length: retain the byte array I pass in

cocoamemory-managementnsstring

I'm working with AsyncSocket where the the AsyncSocket object calls a delegate method below whenever it receives data from remote end:

- (void)onSocket:(AsyncSocket*)socket didReadData:(NSData*)data withTag:(long)tag;

Now, within this method, I pass the NSData object into the following command to get a NSString representation of the data received:

NSString *body = [NSString stringWithCString:[data bytes] length:[data length];

Does NSString stringWithCString: length: retain the byte array I pass in? Do I need to retain the NSData *data? Do I need to be releasing NSString *body at the end?

Thanks. I want to get memory management right in terms of delegates methods…

Best Answer

Does NSString stringWithCString: length: retain the byte array I pass in?

It's not possible to retain a byte array. Only objects can be retained.

Do I need to retain the NSData *data?

No. Because there's no way for the string to retain the data (which it doesn't know about) or its contents, the string will copy the bytes. (Think about what you would do if you were implementing this method: This is it.)

Let's change cases and look at what you would do if you were passing the data object in, instead of the bytes.

If the string does retain the data, then you don't need to worry about the data dying out from under the string, because the string is retaining it. If it doesn't retain it, the string either made its own copy or isn't holding on your data at all.

So other objects' retentions don't matter. Don't worry about them. Worry only about who owns what, and retain or not accordingly.

Do I need to be releasing NSString *body at the end?

Well, you didn't retain it, you didn't alloc it, and you didn't copy it. Therefore, you don't own it. So, no.

If you do want to take ownership of the object, you'd retain it or make (and then own) your own copy. Then you would release it.

Related Solutions

Objective-c – NSString property: copy or retain

For attributes whose type is an immutable value class that conforms to the NSCopying protocol, you almost always should specify copy in your @property declaration. Specifying retain is something you almost never want in such a situation.

Here's why you want to do that:

NSMutableString *someName = [NSMutableString stringWithString:@"Chris"];

Person *p = [[[Person alloc] init] autorelease];
p.name = someName;

[someName setString:@"Debajit"];

The current value of the Person.name property will be different depending on whether the property is declared retain or copy — it will be @"Debajit" if the property is marked retain, but @"Chris" if the property is marked copy.

Since in almost all cases you want to prevent mutating an object's attributes behind its back, you should mark the properties representing them copy. (And if you write the setter yourself instead of using @synthesize you should remember to actually use copy instead of retain in it.)

Ios – What does the NS prefix mean

The original code for the Cocoa frameworks came from the NeXTSTEP libraries Foundation and AppKit (those names are still used by Apple's Cocoa frameworks), and the NextStep engineers chose to prefix their symbols with NS.

Because Objective-C is an extension of C and thus doesn't have namespaces like in C++, symbols must be prefixed with a unique prefix so that they don't collide. This is particularly important for symbols defined in a framework.

If you are writing an application, such that your code is only likely ever to use your symbols, you don't have to worry about this. But if you're writing a framework or library for others' use, you should also prefix your symbols with a unique prefix. CocoaDev has a page where many developers in the Cocoa community have listed their "chosen" prefixes. You may also find this SO discussion helpful.

Best Answer

Related Solutions

Objective-c – NSString property: copy or retain

Ios – What does the NS prefix mean

Related Topic