3

A noob question.

if i have a string @"Hello i am a string". is @"" an object? what is it ? where is it stored?

What will happen if i release an object i did not create? or what are its complications?

NSString *string1 = [[NSString alloc] initWithString:@"string"];
NSString *string2 = string1;
[string2 release];

also another question what's the difference between?

NSString *string1 = [[NSString alloc] initWithString:@"string"];
NSString *string2 = @"string";

I know i'm a noob but i just wanna know.

Thanks in advance

EDIT:

i meant to say alloc initWithString instead of stringWithString

4 Answers4

6

Never release objects you don't own. The rule is quite simple: you only own an object if you obtained it by using new, alloc, retain or copy (NARC for short).

Objects obtained by any other method should be returned autoreleased. What this means is that the object will be released automatically on the next autorelease pool drain. If you want to keep the object, you need to retain it then release it. If you don't care if the object gets deallocated after you finish using it in your current scope, then don't do anything with it.

So, to sum it up:

  • You must pair any NARC with a release
  • You must not pair any non-NARC with a release
  • Non-NARC methods will return autoreleased objects
  • You must retain any autoreleased object if you need it beyond the current scope

To address your specific questions:

  • @"Hello i am a string" is an object. It is an instance of NSConstantString and it gets created at compile time. You cannot and should not release it. It will live on throughout the life of the application. Take a look at this question for more about it.
  • If you release an object you don't own, then you will decrement its retain count and you will cause complications with code that assumes it must not retain it.
Community
  • 1
  • 1
rid
  • 61,078
  • 31
  • 152
  • 193
  • sorry i already know that much. this was not the answer i'm looking for. –  Jul 20 '11 at 18:34
4

NSString *string2 = string1;

That does not create a new object. string1 is not an object, it is a pointer to an object. that assignment merely makes a copy of the pointer and places it in string2.

Due to an implementation detail (an internal implementation detail that may not be true in all cases and should never be relied upon), this is true:

NSString *string1 = [NSString stringWithString:@"string"];
string1 == @"string"; // this is a true expression

String constants -- @"dddd" -- are compiled into the binary by the compiler. They can't be released and there is only one constant per unique string. stringWithString: recognizes constants and does not make a new copy.

Now, if you were to do:

NSMutableString *string1 = [NSMutableString stringWithString:@"string"];
NSMutableString *string2 = string1;
[string2 release];

That would copy the @"string" into a new instance of NSMutableString and string1 would point to that object.

That code, though, would be an over-release ([string1 release]; would be, too) since stringWithString: returns an autoreleased object.

Now, if you were to:

NSMutableString *string1 = [[NSMutableString alloc] initWithString:@"string"];
NSMutableString *string2 = string1;
[string2 release];

Then that code is technically correct in terms of the retain counts; the string object would be deallocated. But after the release, both string1 and string2 would be dangling pointers -- that is, the address they hold no longer points to a viable object and attempting to message either would yield undefined results.

bbum
  • 162,346
  • 23
  • 271
  • 359
  • 1
    To be clear... the implementation detail that allows `string1 == @"string";` deals with `[NSString stringWithString:@"string"];` returning the same constructed string as @"string" not with anything to do with special comparison, the pointers just happen to be the same. – Grady Player Jul 20 '11 at 18:53
1

Releasing an object you didn't create will eventually get you and EXC_BAD_ACCESS exception when the owner of the object tries to release it and it's already deallocated.

Regarding your second question, there's a good discussion here.

Community
  • 1
  • 1
highlycaffeinated
  • 19,729
  • 9
  • 60
  • 91
  • correct me if i'm wrong. this tells me that string2 basically keeps a pointer to string1 and if i release string1 there would be an EXC_BAD_ACCESS in case that the original owner (with +1 retaincounts) released it and thus deallocated it. thank you very much. i just needed to know what @"" is, is it an object or is it even stored in the heap? tell me if you have any knowledge on where i can find the answer. im just curious. :D –  Jul 20 '11 at 18:39
1

When you use the @"" syntax, you are creating an object. It's shorthand for the creation of an immutable string, also known as a NSConstantString under the covers. String constants are stored in the data segment portion of the application binary and are loaded into memory along with the code and referenced during runtime.

As others have mentioned, any time you don't explicitly allocate space for an object, you shouldn't release it. Any time you over-release an object, you'll introduce unexpected, and often random, issues to your application. @Radu's explanation is spot on.

csano
  • 13,266
  • 2
  • 28
  • 45