Objective-C: can initialize one class but not the other - objective-c

Question

I have some objective-C code with a few classes. I'm trying to initialize each of the first two classes within the third class. One works fine, turns the right color in Xcode and allows me to jump to the definition. The other for some reason doesn't. I've poured over it but can't see what distinguishes the two.
MainClass.m:
#import "Class1.h"
#import "Class2.h"
#implementation MainClass
Class1 *class1 = [Class1 new];
Class2 *class2 = [Class2 new];
#end
Class1.h:
#ifndef Class1_h
#define Class1_h
#interface Class1 : NSObject
#end
#endif
Class2.h:
#ifndef Class2_h
#define Class2_h
#interface Class2 : NSObject
#end
#endif
There's no difference in header files of Class1.h and Class2.h. Both are imported into the MainClass.m But for some reason Class2 isn't recognized in MainClass.m, yields "Initializer element is not a compile-time constant" on Build+Run and doesn't allow me to command-click and jump to the definition.
I'm not sure where to look at this point. I've copied and pasted the code from the Class1.m file into Class2.m only changing the #import Class2.h header import and #implementation Class2 lines to make sure its not something in the .m files...problem persists.

Answer 1

You have an apostrophe instead of a double-quote at the end of your second import.

Answer 2

You might have a lingering #define of Class2_h somewhere. (This can happen if you use this #ifndef/#define/#endif pattern, especially if cutting and pasting code.)
For what it’s worth, you really don't need this #ifndef/#define/#endif pattern around your #interface references. Often C programmers are used to using this pattern a lot, but it’s just not needed in Objective-C class definitions.
For example, consider scenario where Class1 had a property that was a Class2:
// Class1.h
#import "Foundation/Foundation.h"
#import "Class2.h"
#interface Class1 : NSObject
#property (nonatomic, strong) Class2 *class2;
#end
And
// Class2.h
#import "Foundation/Foundation.h"
#interface Class2 : NSObject
#end
Then MainClass can import both headers without incident (even though Class1.h currently imports Class2.h already):
// MainClass.m
#import "MainClass.h"
#import "Class1.h"
#import "Class2.h"
#implementation MainClass
- (void)foo {
Class1 *class1 = [Class1 new];
Class2 *class2 = [Class2 new];
NSLog(#"Class1: %#", class1);
NSLog(#"Class2: %#", class2);
}
#end
You would have thought that this redundant #import "Class2.h" would cause problems, but it doesn’t. Objective-C tried to get us out of worrying about all of these #define references.
Now, that having been said, using that above example, Class1.h might not even #import the Class2.h file, at all, but it might just do a forward declaration of the class. And if Class1 implementation needed to interact with Class2 objects, you’d do the #import of Class2.h in Class1.m, not Class1.h:
// Class1.h
#import "Foundation/Foundation.h"
#class Class2;
#interface Class1 : NSObject
#property (nonatomic, strong) Class2 *class2;
#end
But regardless, we just don't tend to use the #ifndef/#define/#endif pattern in Objective-C.