Stałe w celu C

Zajmuję się Cocoa aplikacji i używam stale NSStrings jako sposobów przechowywania nazwy klawiszy do moich preferencji.

Rozumiem, że to dobry pomysł, ponieważ w razie potrzeby umożliwia łatwą zmianę kluczy.
Ponadto jest to całe pojęcie „oddziel swoje dane od logiki”.

W każdym razie, czy istnieje dobry sposób, aby zdefiniować te stałe raz dla całej aplikacji?

Jestem pewien, że istnieje prosty i inteligentny sposób, ale teraz moje klasy po prostu redefiniują te, których używają.

Powinieneś utworzyć plik nagłówka jak

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

(możesz użyć externzamiast, FOUNDATION_EXPORTjeśli twój kod nie będzie używany w mieszanych środowiskach C / C ++ lub na innych platformach)

Możesz dołączyć ten plik do każdego pliku, który używa stałych lub we wstępnie skompilowanym nagłówku projektu.

Zdefiniujesz te stałe w pliku .m, takim jak

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

Constants.m należy dodać do celu aplikacji / frameworka, aby był powiązany z produktem końcowym.

Zaletą używania stałych ciągowych zamiast stałych #defined jest to, że można sprawdzić równość za pomocą wskaźnika porównania ( stringInstance == MyFirstConstant), który jest znacznie szybszy niż porównanie ciągu ( [stringInstance isEqualToString:MyFirstConstant]) (i łatwiejszy do odczytania, IMO).

Najprostszy sposób:

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

Lepszy sposób:

// Prefs.h
extern NSString * const PREFS_MY_CONSTANT;

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

Jedną z zalet drugiej jest to, że zmiana wartości stałej nie powoduje przebudowy całego programu.

Jest też jedna rzecz do wspomnienia. Jeśli potrzebujesz stałej globalnej, powinieneś użyć staticsłowa kluczowego.

Przykład

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

Ze względu na staticsłowo kluczowe ta stała nie jest widoczna poza plikiem.

Drobna korekta @QuinnTaylor : zmienne statyczne są widoczne w jednostce kompilacyjnej . Zwykle jest to pojedynczy plik .m (jak w tym przykładzie), ale może cię ugryźć, jeśli zadeklarujesz go w nagłówku, który jest zawarty w innym miejscu, ponieważ po kompilacji wystąpią błędy linkera

Przyjęta (i poprawna) odpowiedź mówi, że „możesz dołączyć ten plik [Constants.h] ... do wstępnie skompilowanego nagłówka projektu”.

Jako nowicjusz miałem trudności z zrobieniem tego bez dalszego wyjaśnienia - oto jak: W pliku YourAppNameHere-Prefix.pch (jest to domyślna nazwa prekompilowanego nagłówka w Xcode) zaimportuj plik Constants.h wewnątrz #ifdef __OBJC__bloku .

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

Zauważ też, że pliki Constants.h i Constants.m nie powinny zawierać w nich absolutnie nic poza opisanymi w zaakceptowanej odpowiedzi. (Brak interfejsu lub implementacji).

Ogólnie używam sposobu opublikowanego przez Barry'ego Warka i Rahula Gupta.

Chociaż nie lubię powtarzać tych samych słów w plikach .h i .m. Zauważ, że w poniższym przykładzie linia jest prawie identyczna w obu plikach:

// file.h
extern NSString* const MyConst;

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

Dlatego lubię korzystać z niektórych maszyn preprocesora C. Pozwól mi wyjaśnić na przykładzie.

Mam plik nagłówka, który definiuje makro 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

W mojej parze .h / .m, w której chcę zdefiniować stałą, wykonuję następujące czynności:

// 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, mam wszystkie informacje o stałych tylko w pliku .h.

Sam mam nagłówek poświęcony deklarowaniu stałych NSStrings używanych w preferencjach, takich jak:

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

Następnie zadeklaruj je w dołączonym pliku .m:

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";

To podejście mi dobrze służyło.

Edycja: Zauważ, że działa to najlepiej, jeśli ciągi są używane w wielu plikach. Jeśli używa go tylko jeden plik, możesz to zrobić #define kNSStringConstant @"Constant NSString"w pliku .m, który używa łańcucha.

Niewielka modyfikacja sugestii @Krizz, aby działała poprawnie, jeśli plik nagłówka stałych ma być zawarty w PCH, co jest raczej normalne. Ponieważ oryginał jest importowany do PCH, nie załaduje go ponownie do .mpliku, a zatem nie otrzymasz żadnych symboli, a linker jest niezadowolony.

Jednak następująca modyfikacja pozwala mu działać. To trochę skomplikowane, ale działa.

Potrzebne będą 3 pliki, .hplik ze stałymi definicjami, .hplik i .mplik, którego użyję ConstantList.h, Constants.hi Constants.modpowiednio. zawartość Constants.hjest po prostu:

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

i Constants.mplik wygląda następująco:

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

Wreszcie ConstantList.hplik zawiera rzeczywiste deklaracje i to wszystko:

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

Kilka rzeczy do zapamiętania:

1. Musiałem ponownie zdefiniować makro w .mpliku po #undef ing go do makro ma być używany.

2. Musiałem także użyć #includezamiast #importtego, aby działało to poprawnie i unikałem zauważenia przez kompilator wcześniej wstępnie skompilowanych wartości.

3. Będzie to wymagało ponownej kompilacji twojego PCH (i prawdopodobnie całego projektu) za każdym razem, gdy jakiekolwiek wartości zostaną zmienione, co nie ma miejsca, jeśli zostaną one rozdzielone (i powielone) jak zwykle.

Mam nadzieję, że jest to pomocne dla kogoś.

// Prefs.h
extern NSString * const RAHUL;

// Prefs.m
NSString * const RAHUL = @"rahul";

Jak powiedział Abizer, możesz umieścić go w pliku PCH. Innym sposobem, który nie jest tak brudny, jest utworzenie pliku dołączania dla wszystkich kluczy, a następnie albo dołączenie go do pliku, w którym używasz kluczy, albo uwzględnienie go w PCH. Z ich własnym plikiem dołączającym, co najmniej daje jedno miejsce do wyszukiwania i definiowania wszystkich tych stałych.

Jeśli chcesz coś w rodzaju stałych globalnych; szybki i brudny sposób polega na umieszczeniu w pchpliku stałych deklaracji .

Spróbuj użyć metody klasowej:

+(NSString*)theMainTitle
{
    return @"Hello World";
}

Czasem go używam.

Jeśli podoba Ci się stała przestrzeni nazw, możesz wykorzystać struct, piątek Pytania i odpowiedzi 2011-08-19: Stałe przestrzeni nazw i funkcje

// 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"
};

Używam klasy singleton, aby móc wyśmiewać klasę i zmienić stałe, jeśli to konieczne do testowania. Klasa stałych wygląda następująco:

#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

I jest używany w ten sposób (zwróć uwagę na użycie skrótu dla stałych c - za [[Constants alloc] init]każdym razem oszczędza pisania ):

#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

Jeśli chcesz wywołać coś takiego NSString.newLine;z celu c i chcesz, aby była stała statyczna, możesz szybko utworzyć coś takiego:

public extension NSString {
    @objc public static let newLine = "\n"
}

I masz ładną, czytelną stałą definicję, dostępną z wybranego typu, podczas gdy styl jest ograniczony do kontekstu typu.