¿Cuál es la diferencia entre # importar y # incluir en Objective-C?

Parece haber mucha confusión con respecto al preprocesador.

Lo que hace el compilador cuando ve un #include que reemplaza esa línea con el contenido de los archivos incluidos, sin preguntas.

Así que si tienes un archivo a.h con este contenido:

typedef int my_number;

Y un archivo b.c con este contenido:

#include "a.h"
#include "a.h"

El archivo b.c será traducido por el preprocesador antes de la compilación a

typedef int my_number;
typedef int my_number;

Que resultará en un error del compilador, ya que el tipo my_number se define dos veces. A pesar de que la definición es la misma, esto no está permitido por el lenguaje C.

Dado que un encabezado a menudo se usa en más de un lugar include guards generalmente se usan en C. Esto se ve así:

 #ifndef _a_h_included_
 #define _a_h_included_

 typedef int my_number;

 #endif

El archivo b.c todavía tendría todo el contenido de la cabecera en él dos veces después de ser preprocesado. Pero la segunda instancia sería ignorada ya que la macro _a_h_included_ ya habría sido definida.

Esto funciona realmente bueno, pero tiene dos inconvenientes. En primer lugar, los protectores include tienen que ser escritos, y el nombre de la macro tiene que ser diferente en cada encabezado. Y en segundo lugar, el compilador todavía tiene que buscar el archivo de encabezado y leerlo tan a menudo como se incluye.

Objective-C tiene la instrucción del preprocesador #import (también se puede usar para código C y C++ con algunos compiladores y opciones). Esto hace casi lo mismo que #include, pero también señala internamente qué archivo ya se ha incluido. La línea #import solo se reemplaza por el contenido del archivo nombrado por primera vez que se encuentra. Cada vez después de eso es simplemente ignorado.

Estoy de acuerdo con Jason.

Me atraparon haciendo esto:

#import <sys/time.h>  // to use gettimeofday() function
#import <time.h>      // to use time() function

Para GNU gcc, seguía quejándose de que la función time () era no definido.

Entonces cambié #import a #include y todo salió bien.

Razón:

#importas :
     incluye solamente una parte de usando # define

# import :
    No vamos. Aunque solo una parte del tiempo.h > ya estaba incluido, como
    en cuanto a # import se refiere, ese archivo ahora ya está completamente incluido.

En pocas palabras:

Los encabezados C/C++ tradicionalmente incluyen partes de otros archivos include.
Así que para los encabezados C/C++, use # include.
Para las cabeceras objc/objc++, utilice # import.

#include funciona igual que el C #include.

#import realiza un seguimiento de los encabezados que ya se han incluido y se ignora si un encabezado se importa más de una vez en una unidad de compilación. Esto hace innecesario el uso de protectores de cabecera.

La conclusión es simplemente usar #import en Objective-C y no te preocupes si tus encabezados terminan importando algo más de una vez.

Sé que este hilo es viejo... pero en "tiempos modernos".. hay una "estrategia de inclusión" muy superior a través de los módulos @import de clang - que a menudo se pasa por alto..

Los módulos mejoran el acceso a la API de las bibliotecas de software reemplazando el modelo de inclusión de preprocesador textual por un modelo semántico más robusto y eficiente. Desde la perspectiva del usuario, el código se ve solo ligeramente diferente, porque se usa una declaración de importación en lugar de un preprocesador # include directiva:

@import Darwin; // Like including all of /usr/include. @see /usr/include/module.map

O

@import Foundation;  //  Like #import <Foundation/Foundation.h>
@import ObjectiveC;  //  Like #import <objc/runtime.h>

Sin embargo, esta importación de módulos se comporta de manera bastante diferente de la correspondiente #include: cuando el compilador ve la importación de módulos anterior, carga una representación binaria del módulo y hace que su API esté disponible para la aplicación directamente. Las definiciones de preprocesador que preceden a la declaración de importación no tienen ningún impacto en la API proporcionada... porque el módulo en sí fue compilado como un módulo independiente. Además, cualquier indicador de enlace requerido para usar el módulo automáticamente se proporcionará cuando se importe el módulo. Este modelo de importación semántica aborda muchos de los problemas del modelo de inclusión del preprocesador.

Para habilitar los módulos, pase la bandera de línea de comandos -fmodules aka CLANG_ENABLE_MODULES en Xcode-en tiempo de compilación. Como se mencionó anteriormente.. esta estrategia obviará TODO LDFLAGS. Al igual que en, puede eliminar cualquier configuración de "OTHER_LDFLAGS", así como cualquier " Enlace" fase..

Encuentro que los tiempos de compilación / lanzamiento "se sienten" mucho más rápidos (o, posiblemente, hay menos retraso al "enlazar"?).. y también, proporciona una gran oportunidad para purgar el ahora extraño Proyecto-Prefijo.archivo pch y configuración de compilación correspondiente, GCC_INCREASE_PRECOMPILED_HEADER_SHARING, GCC_PRECOMPILE_PREFIX_HEADER, y GCC_PREFIX_HEADER, etc.

También, aunque no está bien documentado can puede crear module.maps para sus propios frameworks e incluirlos de la misma manera conveniente. Puedes echar un vistazo a mi ObjC-Clang-Modules github repo para algunos ejemplos de cómo implementar tales milagros.

Si está familiarizado con C++ y macros, entonces

#import "Class.h" 

Es similar a

{
#pragma once

#include "class.h"
}

Lo que significa que su clase se cargará solo una vez cuando se ejecute su aplicación.

SI #incluye un archivo dos veces .h archivos que compilador dará error. Pero si #importas un archivo más de una vez el compilador lo ignorará.

En may case tenía una variable global en uno de mis archivos .h que estaba causando el problema, y lo resolví agregando extern delante de él.

#include solía obtener "cosas" de otro archivo al que se usa #include. Ex:

En archivo: main.cpp

#include "otherfile.h"

// some stuff here using otherfile.h objects,
// functions or classes declared inside

Header guard se usa en la parte superior de cada archivo de encabezado (*.h) para evitar incluir el mismo archivo más de una vez (si sucede, obtendrá errores de compilación).

En archivo: otherfile.h

#ifndef OTHERFILE
#define OTHERFILE

// declare functions, classes or objects here

#endif

Incluso si pones #include "otherfile.h" n tiempo en su código, esto dentro de no declararse.