Objective-c 中的常数

I'm developing a Cocoa application, and I'm using constant NSStrings as ways to store key names for my preferences.

I understand this is a good idea, because it allows easy changing of keys if necessary. Plus, it's the whole 'separate your data from your logic' notion.

Anyway, is there a good way to make these constants defined once for the whole application? I'm sure that there's an easy and intelligent way, but right now my classes just redefine the ones they use.

转载于:https://stackoverflow.com/questions/538996/constants-in-objective-c

csdnceshi54
hurriedly% OOP is about grouping your data with your logic. What are you proposing is just a good programming practice, i.e., making your program easy to change.
接近 9 年之前 回复

13个回答

You should create a header file like

// Constants.h
FOUNDATION_EXPORT NSString *const MyFirstConstant;
FOUNDATION_EXPORT NSString *const MySecondConstant;
//etc.

(you can use extern instead of FOUNDATION_EXPORT if your code will not be used in mixed C/C++ environments or on other platforms)

You can include this file in each file that uses the constants or in the pre-compiled header for the project.

You define these constants in a .m file like

// Constants.m
NSString *const MyFirstConstant = @"FirstConstant";
NSString *const MySecondConstant = @"SecondConstant";

Constants.m should be added to your application/framework's target so that it is linked in to the final product.

The advantage of using string constants instead of #define'd constants is that you can test for equality using pointer comparison (stringInstance == MyFirstConstant) which is much faster than string comparison ([stringInstance isEqualToString:MyFirstConstant]) (and easier to read, IMO).

csdnceshi60
℡Wang Yan Does this work with ARC? I am having issues where my const NSStrings are null at runtime.
大约 3 年之前 回复
csdnceshi52
妄徒之命 These constants are global variables and therefore could potentially conflict with global variables of frameworks added to the project?
大约 4 年之前 回复
csdnceshi77
狐狸.fox This solution won't work if I have localized string right?
5 年多之前 回复
weixin_41568196
撒拉嘿哟木头 With MyConst defined as you have, including the .h file in multiple spots (as desired by the OP) would result in a duplicate symbol error during linking.
5 年多之前 回复
csdnceshi56
lrony* I'm curious, and in searching haven't found a good answer to this question. What is the benefit of declaring the constant in two places? I know with the extern keyword it must be defined and then initialized in separate lines, but why not just use NSString *const MyConstant = @"MyConstantValue" in a single .h file?
5 年多之前 回复
weixin_41568208
北城已荒凉 Once we do this, how do we access/use these constants from other classes? I am trying "Constants.MY_CONSTANT" but I am getting a "Property MY_CONSTANTS not found on object of type Constants" error.
大约 6 年之前 回复
csdnceshi78
程序go Actually, it reduces the footprint because it makes sure that the string constant only exists once in your program. If you use #define, you could have a different string every time the constant is used. BTW. strings created like @"string" are never deallocated, and copy doesn't copy them.
6 年多之前 回复
csdnceshi50
三生石@ If I define all my constant strings in such a manner, does it increase my memory footprint?
6 年多之前 回复
csdnceshi80
胖鸭 totally agree with ben! You really shouldn't use ==
6 年多之前 回复
weixin_41568110
七度&光 Do not use == for string comparisons under any circumstances. Yes, if you understand the compiler/runtime (!), and you're careful, you can get it right. But it's a leaky abstraction, and requires special invisible knowledge in one part of a codebase about the way another part is put together. @BarryWark: I do sympathize with your point about using them as "symbols" and scoping their use to that sort of thing, but even then, because they are declared publicly as NSStrings, their "symbolness" is also special knowledge. Better to be consistent about compares and trust -isEqualToString:.
接近 7 年之前 回复
csdnceshi71
Memor.の For the record, == should work for NSStrings due to string interning, as long as you're working with constant, immutable strings (i.e. not +stringWithFormat:). However, -isEqualToString:, if it is implemented correctly, should short-circuit itself with a pointer equality check first. But, I should note, all of these shoulds could change, so write defensively.
接近 7 年之前 回复
csdnceshi73
喵-见缝插针 FOUNDATION_EXPORT is a minor convenience that defines as FOUNDATION_EXTERN which in turn defines as extern "C" for C++ and otherwise as extern (other than a slight difference for windows as target...meh)
7 年多之前 回复
csdnceshi63
elliott.david A note/warning. There can be problems when using NSString constants like this with ARC. Sometimes the constant is unexpectedly automatically released while app is running (I've experienced that while passing const string to NSNotificationCenter, as notification name. At first pass it works fine, but when I want to emit second notification the app gets crashed with "bad memory access"). So, I was end up with #define-styled constants.
7 年多之前 回复
weixin_41568174
from.. Awesome solution, just needed to read all the thread to figure out how to add the class to pch file.
7 年多之前 回复
csdnceshi67
bug^君 I get "Undefined symbols for architecture i386" for this...
7 年多之前 回复
csdnceshi74
7*4 Don't assign your const a value in the header file -- instead assign the value in the .m file. You'll still need to declare the const (without assigning a value) in the .h file.
接近 8 年之前 回复
csdnceshi51
旧行李 in my case when I used extern int const playBoardBlock = 1; in const.h file it comes with a warning, i.e. 'ertern' variable has an initializer, what's the suggestion.
接近 8 年之前 回复
csdnceshi70
笑故挽风 After doing all you can use these constant by just putting name of the constant like NSLog(@"%@",MyFirstConstant); in all application
8 年多之前 回复
csdnceshi74
7*4 == for string equality test works in some circumstances, as has been noted, but I think it's just a bad idea. It's too fragile in that a change in coding style or a changed design decision later on will cause the 'correctness' of using == to break. It could really come back and bite you on the rump.
8 年多之前 回复
csdnceshi55
~Onlooker How does one localize these strings? NSLocalizedString seems to fail.
8 年多之前 回复
weixin_41568184
叼花硬汉 WRT using == to test for constant equality, this is technically OK but in practice a bad idea. Consider the case where you are consuming a JSON response from an HTTP server and checking if a key in the dictionary is a known key name constant. Using == in this case will fail, because the JSON parser constructed unique NSString* objects for your dictionary keys that you are trying to compare against other NSString* objects that of course have a different memory address. Be sane and use isEqualToString and let the runtime deal with memory addressing.
8 年多之前 回复
csdnceshi66
必承其重 | 欲带皇冠 I had problems with this method related to my inexperience with the pch file that were answered here: stackoverflow.com/questions/7439011/…
大约 9 年之前 回复
csdnceshi57
perhaps? once you're using constants as strings (e.g. with a copy property), all bets are off. You should be using isEqualToString: to check for equality in this case. But you would have to do that if you used #defined strings as well.
9 年多之前 回复
csdnceshi62
csdnceshi62 Can anyone give me a hint on how to do this in XCode 4? (adding Constants.m to the application/framework's target)
9 年多之前 回复
csdnceshi76
斗士狗 In Cocoa, I have seen a number of classes that define their NSString properties with copy instead of retain. As such, they could (and should) be holding a different instance of your NSString* constant, and direct memory address comparison would fail. Also, I would presume that any reasonably optimal implementation of -isEqualToString: would check for pointer equality before getting into the nitty-gritty of character comparison.
9 年多之前 回复
csdnceshi64
游.程 I just know this trick recently and found that its very good trick!
9 年多之前 回复
csdnceshi59
ℙℕℤℝ +1 for "Constants.m should be added to your application/framework's target so that it is linked in to the final product." Saved my sanity. @amok, do "Get info" on Constants.m and choose the "Targets" tab. Make sure it's checked for the relevant target(s).
大约 10 年之前 回复
csdnceshi57
perhaps? Yes, Constants.m needs to be linked (either statically as part of the target) or via a framework to any code that uses the constants.
大约 10 年之前 回复
csdnceshi53
Lotus@ how do I do this: Constants.m should be added to your application/framework's target so that it is linked in to the final product. ?
大约 10 年之前 回复
weixin_41568131
10.24 This works fine when compiling my app, but when compiling a static library with the same files, I get a weird error: "'asm' or 'attribute' before '*' token". Any ideas what's up with that?
10 年多之前 回复
weixin_41568134
MAO-EYE Followup question: Let's say you've declared a static NSArray. Memory management rules (say on the iPhone) normally mandate retain/release balancing. Because this is static, do you do anything differently? For instance, I imagine I could alloc/init ... and then release in the dealloc. Is that all there is to it? (I've seen sample code where there is no release in the dealloc, and that left me a bit suspicious.)
10 年多之前 回复
csdnceshi57
perhaps? In this case, it's OK to use == to test for equality with the constant, if it's truly used as a constant symbol (i.e. the symbol MyFirstConstant instead of a string containing @"MyFirstConstant" is used). An integer could be used instead of a string in this case (really, that's what you're doing--using the pointer as an integer) but using a constant string makes debugging slightly easier as the value of the constant has human-readable meaning.
11 年多之前 回复
weixin_41568126
乱世@小熊 Overall, great answer, with one glaring caveat: you DO NOT want to test for string equality with the == operator in Objective-C, since it tests memory address. Always use -isEqualToString: for this. You can easily get a different instance by comparing MyFirstConstant and [NSString stringWithFormat:MyFirstConstant]. Make no assumptions about what instance of a string you have, even with literals. (In any case, #define is a "preprocessor directive", and is substituted before compilation, so either way the compiler sees a string literal in the end.)
11 年多之前 回复
csdnceshi57
perhaps? Yes, in the C++ world, const NSString * const MyConstant is correct. Since Objective-C is a C superset, however, const correctness is not part of its history and you get many warnings about passing the incrrect (const) pointer to methods that expect an NSString* even though an NSString * is immutable so could be declared const NSString *.
11 年多之前 回复
csdnceshi68
local-host Is it better to say: extern const NSSTring *const MyFirstConstant ?
11 年多之前 回复
csdnceshi65
larry*wei For an integer constant would it be: extern int const MyFirstConstant = 1;
11 年多之前 回复

Easiest way:

// Prefs.h
#define PREFS_MY_CONSTANT @"prefs_my_constant"

Better way:

// Prefs.h
extern NSString * const PREFS_MY_CONSTANT;

// Prefs.m
NSString * const PREFS_MY_CONSTANT = @"prefs_my_constant";

One benefit of the second is that changing the value of a constant does not cause a rebuild of your entire program.

weixin_41568110
七度&光 If I define all my constant strings in such a manner, does it increase my memory footprint?
6 年多之前 回复
weixin_41568184
叼花硬汉 - Someplace where only the compiler knows the answer. IE, if you wanted to include in an about menu which compiler was used to compile a build of an application, you could place it there since the compiled code otherwise wouldn't have anyway of knowing. I can't think of many other places. Macros certainly shouldn't be used in many places. What if I had #define MY_CONST 5 and elsewhere #define MY_CONST_2 25. The result is that you may very well end up with a compiler error when it tries to compile 5_2. Do not use #define for constants. Use const for constants.
7 年多之前 回复
csdnceshi56
lrony* when should macros be used, if not here?
7 年多之前 回复
weixin_41568184
叼花硬汉 This is more than just a preference - you're using macros when you shouldn't. It's like using goto - it exists for legacy and for some special cases (IE, to break from an inner loop,) but shouldn't be used elsewhere. If you just want a constant, you should use a const. It's what they were made/introduced for.
7 年多之前 回复
csdnceshi65
larry*wei Header files get #includeed into many .m files. In all C languages this basically a copy and paste into one translation unit. The short version is that if you do it in the header, changing the value may cause a lot of files to be recompiled. This will become noticable on large projects (maybe 50k+ SLOC)
大约 8 年之前 回复
csdnceshi54
hurriedly% What happen, if I use this declaration in the header file, static NSString * const kNSStringConst = @"const value"; What's the difference between not declaring and init separately in .h and .m files?
8 年多之前 回复
csdnceshi67
bug^君 Is there any added value in doing extern NSString const * const MyConstant, ie, making it a constant pointer to a constant object rather than just a constant pointer?
8 年多之前 回复
csdnceshi53
Lotus@ Andrew is refering to changing the value of the constant while coding, not while the application is running.
10 年多之前 回复
csdnceshi72
谁还没个明天 I thought you were not supposed to change the value of constants.
接近 11 年之前 回复

There is also one thing to mention. If you need a non global constant, you should use static keyword.

Example

// In your *.m file
static NSString * const kNSStringConst = @"const value";

Because of the static keyword, this const is not visible outside of the file.


Minor correction by @QuinnTaylor: static variables are visible within a compilation unit. Usually, this is a single .m file (as in this example), but it can bite you if you declare it in a header which is included elsewhere, since you'll get linker errors after compilation

weixin_41568134
MAO-EYE If I put this in a header file, what's the problem?
5 年多之前 回复
csdnceshi65
larry*wei Yes, I was referring to the variable's name. Is it standard Apple convention? Why not STRING_CONST instead of StringConst. Is this only in the Java world?
5 年多之前 回复
csdnceshi63
elliott.david value";
5 年多之前 回复
csdnceshi65
larry*wei Why this naming?
5 年多之前 回复
csdnceshi63
elliott.david ...
5 年多之前 回复
csdnceshi68
local-host In which part of the .m file do you place this?
6 年多之前 回复
weixin_41568126
乱世@小熊 static in a header file doesn't give linker problems. However, each compilation unit including the header file will get its own static variable, so you get 100 of them if you include the header from 100 .m files.
6 年多之前 回复
csdnceshi52
妄徒之命 Ok, just checked... Xcode doesn't provide autocompletion for it in other files if you leave static off, but I tried putting the same name in two different places, and reproduced Quinn's linker errors.
接近 9 年之前 回复
csdnceshi52
妄徒之命 If I don't use the static keyword, will kNSStringConst be available throughout the project?
接近 9 年之前 回复
csdnceshi76
斗士狗 Minor correction: static variables are visible within a compilation unit. Usually, this is a single .m file (as in this example), but it can bite you if you declare it in a header which is included elsewhere, since you'll get linker errors after compilation.
11 年多之前 回复

The accepted (and correct) answer says that "you can include this [Constants.h] file... in the pre-compiled header for the project."

As a novice, I had difficulty doing this without further explanation -- here's how: In your YourAppNameHere-Prefix.pch file (this is the default name for the precompiled header in Xcode), import your Constants.h inside the #ifdef __OBJC__ block.

#ifdef __OBJC__
  #import <UIKit/UIKit.h>
  #import <Foundation/Foundation.h>
  #import "Constants.h"
#endif

Also note that the Constants.h and Constants.m files should contain absolutely nothing else in them except what is described in the accepted answer. (No interface or implementation).

weixin_41568184
叼花硬汉 I did this but some files throw error on compile "Use of undeclared identifier 'CONSTANTSNAME' If I include the constant.h in the file throwing the error, it works, but that is not what I want to do. I have cleaned, shutdown xcode and build and still problems... any ideas?
大约 8 年之前 回复

I am generally using the way posted by Barry Wark and Rahul Gupta.

Although, I do not like repeating the same words in both .h and .m file. Note, that in the following example the line is almost identical in both files:

// file.h
extern NSString* const MyConst;

//file.m
NSString* const MyConst = @"Lorem ipsum";

Therefore, what I like to do is to use some C preprocessor machinery. Let me explain through the example.

I have a header file which defines the macro STR_CONST(name, value):

// StringConsts.h
#ifdef SYNTHESIZE_CONSTS
# define STR_CONST(name, value) NSString* const name = @ value
#else
# define STR_CONST(name, value) extern NSString* const name
#endif

The in my .h/.m pair where I want to define the constant I do the following:

// myfile.h
#import <StringConsts.h>

STR_CONST(MyConst, "Lorem Ipsum");
STR_CONST(MyOtherConst, "Hello world");

// myfile.m
#define SYNTHESIZE_CONSTS
#import "myfile.h"

et voila, I have all the information about the constants in .h file only.

csdnceshi55
~Onlooker I can't get this working. If I put #define SYNTHESIZE_CONSTS before #import "myfile.h" it does NSString*... in both the .h and .m (Checked using the assistant view and preprocessor). It throws redefinition errors. If I put it after #import "myfile.h" it does extern NSString*... in both files. Then it throws "Undefined symbol" errors.
6 年多之前 回复
csdnceshi71
Memor.の Hmm, there is a bit of a caveat however, you cannot use this technique like this if the header file is imported into the precompiled header, because it won't load the .h file into the .m file because it was already compiled. There is a way though - see my answer (since I can't put nice code in the comments.
接近 9 年之前 回复

A slight modification of the suggestion of @Krizz, so that it works properly if the constants header file is to be included in the PCH, which is rather normal. Since the original is imported into the PCH, it won't reload it into the .m file and thus you get no symbols and the linker is unhappy.

However, the following modification allows it to work. It's a bit convoluted, but it works.

You'll need 3 files, .h file which has the constant definitions, the .h file and the .m file, I'll use ConstantList.h, Constants.h and Constants.m, respectively. the contents of Constants.h are simply:

// Constants.h
#define STR_CONST(name, value) extern NSString* const name
#include "ConstantList.h"

and the Constants.m file looks like:

// Constants.m
#ifdef STR_CONST
    #undef STR_CONST
#endif
#define STR_CONST(name, value) NSString* const name = @ value
#include "ConstantList.h"

Finally, the ConstantList.h file has the actual declarations in it and that is all:

// ConstantList.h
STR_CONST(kMyConstant, "Value");
…

A couple of things to note:

  1. I had to redefine the macro in the .m file after #undefing it for the macro to be used.

  2. I also had to use #include instead of #import for this to work properly and avoid the compiler seeing the previously precompiled values.

  3. This will require a recompile of your PCH (and probably the entire project) whenever any values are changed, which is not the case if they are separated (and duplicated) as normal.

Hope that is helpful for someone.

csdnceshi80
胖鸭 In answer to the performance compared to the accepted answer, there is none. It is effectively the exact same thing from the point of view of the compiler. You end up with the same declarations. They'd be EXACTLY the same if you replaced the extern above with the FOUNDATION_EXPORT.
大约 5 年之前 回复
csdnceshi74
7*4 Does this have any performance/memory loss when compared to the accepted answer?
5 年多之前 回复
weixin_41568196
撒拉嘿哟木头 Using #include fixed this headache for me.
7 年多之前 回复

If you want something like global constants; a quick an dirty way is to put the constant declarations into the pch file.

csdnceshi59
ℙℕℤℝ no...it's quick but DIRTY
7 年多之前 回复
weixin_41568110
七度&光 Editing the .pch is usually not the best idea. You'll have to find a place to actually define the variable, almost always a .m file, so it makes more sense to declare it in the matching .h file. The accepted answer of creating a Constants.h/m pair is a good one if you need them across the whole project. I generally put constants as far down the hierarchy as possible, based on where they will be used.
11 年多之前 回复

I myself have a header dedicated to declaring constant NSStrings used for preferences like so:

extern NSString * const PPRememberMusicList;
extern NSString * const PPLoadMusicAtListLoad;
extern NSString * const PPAfterPlayingMusic;
extern NSString * const PPGotoStartupAfterPlaying;

Then declaring them in the accompanying .m file:

NSString * const PPRememberMusicList = @"Remember Music List";
NSString * const PPLoadMusicAtListLoad = @"Load music when loading list";
NSString * const PPAfterPlayingMusic = @"After playing music";
NSString * const PPGotoStartupAfterPlaying = @"Go to startup pos. after playing";

This approach has served me well.

Edit: Note that this works best if the strings are used in multiple files. If only one file uses it, you can just do #define kNSStringConstant @"Constant NSString" in the .m file that uses the string.

If you like namespace constant, you can leverage struct, Friday Q&A 2011-08-19: Namespaced Constants and Functions

// in the header
extern const struct MANotifyingArrayNotificationsStruct
{
    NSString *didAddObject;
    NSString *didChangeObject;
    NSString *didRemoveObject;
} MANotifyingArrayNotifications;

// in the implementation
const struct MANotifyingArrayNotificationsStruct MANotifyingArrayNotifications = {
    .didAddObject = @"didAddObject",
    .didChangeObject = @"didChangeObject",
    .didRemoveObject = @"didRemoveObject"
};
csdnceshi71
Memor.の A great thing! But under ARC you will need to prefix all variables in struct declaration with __unsafe_unretained qualifier to get it working.
大约 5 年之前 回复

I use a singleton class, so that I can mock the class and change the constants if necessary for testing. The constants class looks like this:

#import <Foundation/Foundation.h>

@interface iCode_Framework : NSObject

@property (readonly, nonatomic) unsigned int iBufCapacity;
@property (readonly, nonatomic) unsigned int iPort;
@property (readonly, nonatomic) NSString * urlStr;

@end

#import "iCode_Framework.h"

static iCode_Framework * instance;

@implementation iCode_Framework

@dynamic iBufCapacity;
@dynamic iPort;
@dynamic urlStr;

- (unsigned int)iBufCapacity
{
    return 1024u;
};

- (unsigned int)iPort
{
    return 1978u;
};

- (NSString *)urlStr
{
    return @"localhost";
};

+ (void)initialize
{
    if (!instance) {
        instance = [[super allocWithZone:NULL] init];
    }
}

+ (id)allocWithZone:(NSZone * const)notUsed
{
    return instance;
}

@end

And it is used like this (note the use of a shorthand for the constants c - it saves typing [[Constants alloc] init] every time):

#import "iCode_FrameworkTests.h"
#import "iCode_Framework.h"

static iCode_Framework * c; // Shorthand

@implementation iCode_FrameworkTests

+ (void)initialize
{
    c  = [[iCode_Framework alloc] init]; // Used like normal class; easy to mock!
}

- (void)testSingleton
{
    STAssertNotNil(c, nil);
    STAssertEqualObjects(c, [iCode_Framework alloc], nil);
    STAssertEquals(c.iBufCapacity, 1024u, nil);
}

@end
共13条数据 1 尾页
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
立即提问
相关内容推荐