Comparison of @class #import use

1.import will contain all the information about this class, including the entity variables and methods, and @class just tells the compiler that the name that is declared after it is the name of the class, as to how these classes are defined, for the time being, will tell you later.

2. In the header file, it is generally only necessary to know the name of the referenced class. There is no need to know the entity variables and methods inside, so it is common to use @class in the header file to declare that the name is the name of the class. In the implementation class, you need to use #import to include the header file of the referenced class, because it will use the internal entity variables and methods of the referenced class.

3. In terms of compilation efficiency, if you have 100 header files that #import the same head file, or if the files are referenced in turn, such as A–>b, B–>c, C–>d, and so on. When the first header file changes, all the subsequent classes that reference it need to be recompiled, which can take a lot of time if you have a lot of classes. Instead of using @class, you don't.

4. If there are cyclic dependencies, such as A–>b, b–>a such interdependencies, if the use of #import to each other, then there will be a compilation error, if you use @class in the header files of two classes to declare each other, there will be no compile errors appear.

So, in general, the @class is put in interface, just to refer to this class in interface to use this class as a type. In the implementation class that implements this interface, if you need to reference the entity variables or methods of this class, you need to import the classes declared in @class.

Give an example to illustrate.

In the ClassA.h
#import ClassB.h equivalent to include the entire. h header file. If there are many. m files #import ClassA.h, then these files will #import ClassB.h add unnecessary #import and waste compilation time when compiling. In large software, it is important to reduce the include in. h files.

If
Just ClassB that there is no include ClassB.h. Only need to #import ClassB.h in. m files that need to be ClassB.

So when can I use it?
If you only need to declare a CLASSB pointer in ClassA.h, you can declare it in ClassA.h
@ClassB
...
ClassB *pointer;

Suppose that there are two classes: ClassA and CLASSB, two of which are used to each other, which constitutes the circular dependency (cyclic dependency). If in the header file only uses #import to contain each other's header file (constitutes circular inclusions, the loop contains), the compiler will error:

Expected specifier-qualifier-list before ' ClassA '

Or

Expected specifier-qualifier-list before ' ClassB '

In order to avoid the loop contains, in the ClassA.h file with @class CLASSB the CLASSB included, similarly, in the ClassB.h file with @class ClassA to include ClassA. The @class instruction just tells the compiler that this is a class, leaving a space to hold the pointer.

Next, it is likely that in CLASSA.M and CLASSB.M there will be access to the members of the included objects, you must let the compiler know more information, such as what the class can be called, you must use the #import, again to use the class contained in, Tells the compiler what additional information is required.

Otherwise, the compiler warns you:

Warning:receiver ' ClassA ' is a forward class and corresponding @interface could not exist

In another case, use the categories class to include the categories in the. h header file with #import.

In short, the principle of use is:

In the header file only #import the superclass message file inside #import need to send a message in the past class other places to use @class to turn to the declaration

Comparison of @class #import use