NSString vs NSMutableString with stringByAppendingString

So, I'm fairly certain that if I plan on manipulating strings often, such as with stringByAppendingString, I should be using variables of type NSMutableString.

But what if I'm doing something like this?

UILabel *someLabel = [[UILabel alloc] init];
[someLabel setText: [[someDictionary objectForKey:@"some_key"] stringByAppendingString:@"some other string"];

I read that if you use stringByAppendingString on an NSString, you end up with leaks because the pointer associated with the initial NSStrin开发者_如何学Gog moves around, pointing to the new string created by the append, whereas with NSMutableString, your pointer always points to that mutable string.

So my question is, what is implicitly happening when I call stringByAppendingString on something that is a string, but not explicitly an NSString or an NSMutableString? Such as, in my above case, the value of some key in a dictionary. Is doing this wrong, and should I be doing something like below?

[[[NSMutableString stringWithString:[someDictionary objectForKey:@"some_key"]] stringByAppendingString:@"some other string"]]

I read that if you use stringByAppendingString on an NSString, you end up with leaks because the pointer associated with the initial NSString moves around, pointing to the new string created by the append, whereas with NSMutableString, your pointer always points to that mutable string.

That sounds like the advice of someone who didn't quite have a grasp of what is going on with the memory management. Sure, [NSString stringByAppendingString] returns a new string. But what you do with that new string is up to you. You could certainly cause a memory leak by reassigning the result to a retained property in a careless fashion, like so:

myStringProperty = [myStringProperty stringByAppendingString:@" more bits"];

The correct form would be to use self, like so:

self.myStringProperty = [myStringProperty stringByAppendingString:@" more bits"];

Follow the cocoa memory guidelines.

As for dictionaries and other collection types: treat what comes out of the dictionary appropriately given the type you know it to be. If you pull an object out which is actually an NSString, but try to use it as a NSMutableString, your app will fall over (with 'selector not found' or similar). So in that case, you do need to make a new NSMutableString from the NSString.

Interesting note: Apple chose to make NSMutableString a subclass of NSString. Something about that seems unwise to me -- if something looks to be immutable, because it has type NSString, I want it to be immutable! (But in fact it could be NSMutableString.) Compare that to Java, which has a String class and a completely separate BufferedString class.

I've always been a fan of [NSString stringWithFormat@"%@%@", a, b]; because then you clearly get a new autoreleased string and can dispose of "a" and "b" correctly.

With [someDictionary objectForKey:@"some_key"], you will be getting the type of object that was put into that dictionary originally. So blindly calling stringByAppendingString without knowledge of what's in that dictionary seems like a bad idea.

-stringByAppendingString is going to return you a new NSString that is distinct from both strings involved. In other words:

NSString *string3 = [string1 stringByAppendingString:string2];

string3 is an entirely new string. string1 isn't changed at all, nothing happens to its memory location or contents. The person who told you that probably just misunderstood what was going on.

[mutableString1 appendString:string2];

In this case, mutableString1 still points at the same object, but the contents of that object have been altered to include string2.

One last thing to keep in mind is that if you are using mutable strings, you should be careful with sharing references to it. If you pass your mutable string to some function which keeps a pointer to that mutable string and then your code changes that mutable string at some point in the future, the other reference is pointing at exactly the same object which means the other code will see the change as well. If that's what you want, great, but if not you must be careful.

One way to help avoid this problem is to declare your @property statements for NSStrings to be "copy" instead of "retain". That will make a copy of your mutable string before setting it in your property and the -copy method implicitly gives you a NON-mutable version, so it'll create an NSString copy of your NSMutableString.

If you follow the rules for memory management, you will be fine using stringByAppendingString. In a nutshell:

1. if you own an object, you need to release or autorelease it at some point.
2. you own an object if you use an alloc, new, or copy method to create it, or if you retain it.

Make sure you read up on Apple's Memory Management Rules.

In the first code sample in your question, you aren't using alloc, new, copy or retain on any of the NSStrings involved, so you don't need to do anything to release it. If outside of the code that you've included in the sample you are using alloc, new, copy or retain on any NSStrings, you would need to ensure that they are released later.