sirve - que hace#include en c++

¿Cómo se usa la directiva#include correctamente?

Question

¿Hay algún material sobre cómo usar #include correctamente? No encontré ningún libro de texto C / C ++ que explique este uso en detalle. En un proyecto formal, siempre me confundo al tratarlo.

Answer 1

Además de los demás comentarios, recuerde que no necesita #incluir un encabezado en otro encabezado si solo tiene un puntero o referencia. P.ej:

Encabezado requerido:

#include "Y.h"
class X
{
   Y y; // need header for Y
};

Encabezado no requerido:

class Y; 
class X
{
   Y* y; // don''t need header for Y
};
//#include "Y.h" in .cpp file

El segundo ejemplo compila más rápido y tiene menos dependencias. Esto puede ser importante en grandes bases de código.

Answer 2

El grande que siempre me hizo tropezar fue este:

Esto busca en la ruta del encabezado:

#include <stdio.h>

Esto busca en su directorio local:

#include "myfile.h"

Lo segundo que debe hacer con CADA encabezado es este:

myfilename.h:

#ifndef MYFILENAME_H
#define MYFILENAME_H
//put code here
#endif

Este patrón significa que no se puede caer en la redefinición de los encabezados en su compilación (Cheers to orsogufo por señalarme esto se llama "incluir guardia"). Lee un poco sobre cómo el compilador de C realmente compila los archivos (antes de vincularlos) porque eso hará que el mundo de #define y #include tenga mucho sentido para ti, el compilador de C cuando se trata de analizar texto no es muy inteligente. (Sin embargo, el compilador de C es otro asunto)

Answer 3

Los archivos de encabezado son la forma en que C separa la interfaz y la implementación. Se dividen en dos tipos: archivos de cabecera estándar y definidos por el usuario. Un archivo de cabecera estándar, como string.h, nos permite acceder a la funcionalidad de una biblioteca de C subyacente. Deberías #incluirlo en cada archivo .c que usa la funcionalidad relevante. Por lo general, esto usa corchetes como en #include. Un archivo de cabecera definido por el usuario expone su implementación de funciones a otros programadores u otras partes de su código C. Si ha implementado un módulo llamado rational.c para cálculos con números racionales, debe tener un archivo rational.h correspondiente para su interfaz pública. Todo archivo que use la funcionalidad debe incluir #include rational.h, y también rational.c debe #incluirlo. Por lo general, esto se hace usando #include "rational.h" La parte de compilación que hace #includes se llama preprocesador C. Principalmente hace sustituciones de texto y pega texto. Spence es correcto en su patrón para evitar #includes duplicados, que estropean el espacio de nombres. Esta es la base de la inclusión, GNU Make te ofrece mucha más potencia y muchos más problemas también.

Answer 4

Solo una adición a la respuesta de Andy Brice, también puede conformarse con las declaraciones hacia adelante para los valores de retorno de función:

class Question;
class Answer;

class UniversityChallenge
{
...
    Answer AskQuestion( Question* );
...
};

Aquí hay un enlace a una pregunta que hice hace un tiempo con algunas buenas respuestas http://bytes.com/groups/c/606466-forward-declaration-allowed .

Answer 5

Por lo tanto, su compilador puede admitir 2 rutas de búsqueda únicas para incluir archivos:
Informalmente podríamos llamar el sistema include path y el user include path.
El #include <XX> busca en el sistema la ruta incluida.
El #include "XX" busca en la ruta de inclusión del usuario, luego el sistema incluye la ruta.

Comprobación del proyecto de norma n2521:
Sección 16.2:

2 A preprocessing directive of the form 

  # include < h-char-sequence> new-line 

  searches a sequence of implementation-defined places for a header identified
  uniquely by the specified sequence between the < and > delimiters, and
  causes the replacement of that directive by the entire contents of the
  header. How the places are specified or the header identified is
  implementation-defined. 

3 A preprocessing directive of the form 

  # include " q-char-sequence" new-line 

  causes the replacement of that directive by the entire contents of the
  source file identified by the specified sequence between the " " delimiters.
  The named source file is searched for in an implementation-defined manner.
  If this search is not supported, or if the search fails, the directive is
  reprocessed as if it read

  # include < h-char-sequence> new-line 

  with the identical contained sequence (including > characters, if any)
  from the original directive. 

Un ejemplo de esto sería por gcc

  -isystem <dir>              Add <dir> to the start of the system include path
  -idirafter <dir>            Add <dir> to the end of the system include path
  -iwithprefix <dir>          Add <dir> to the end of the system include path
  -iquote <dir>               Add <dir> to the end of the quote include path
  -iwithprefixbefore <dir>    Add <dir> to the end of the main include path
  -I <dir>                    Add <dir> to the end of the main include path

Para ver dónde está buscando tu gcc, haz lo siguiente:

g++ -v -E -xc++ /dev/null -I LOOK_IN_HERE
#include "..." search starts here:
#include <...> search starts here:
  LOOK_IN_HERE
  /usr/include/c++/4.0.0
  /usr/include/c++/4.0.0/i686-apple-darwin9
  /usr/include/c++/4.0.0/backward
  /usr/local/include
  /usr/lib/gcc/i686-apple-darwin9/4.0.1/include
  /usr/include
  /System/Library/Frameworks (framework directory)
  /Library/Frameworks (framework directory)
End of search list.

Entonces, ¿cómo usas este conocimiento?
Hay varias escuelas de pensamiento. Pero siempre hago una lista de mis bibliotecas, desde la más específica hasta la más general.

Ejemplo

Archivo: plop.cpp

#include "plop.h"
#include "plop-used-class.h"

/// C Header Files
#include <stdio.h>    // I know bad example but I drew a blank

/// C++ Header files
#include <vector>
#include <memory>

De esta forma, si el archivo de encabezado "plop-used-class.h" debería haber incluido <vector> esto será compilado por el compilador. Si hubiera puesto el <vector> en la parte superior, este error se habría ocultado del compilador.

Answer 6

• Compruebe el diseño de software de C ++ a gran escala de John Lakos si tiene el dinero.
• Las pautas de codificación de Google C ++ también tienen algunas cosas ACEPTABLES.
• Consulte los materiales de Sutter Herb en línea (blog) también.

Básicamente, debe comprender dónde NO se requieren encabezados incluidos, por ej. declaración adelante. También intente asegurarse de que los archivos de inclusión se compilen uno por uno, y solo incluya #includes en h archivos cuando sea necesario (por ejemplo, plantillas).

Answer 7

Editar: Andy Brice también hizo este punto de una manera más breve.

Siguiendo en la respuesta de null, lo más importante en que pensar es dónde pones tus #includes.

Cuando escribe un #include, el preprocesador literalmente incluye el contenido del archivo que lista en el archivo actual, incluyendo cualquier #includes en esos archivos también. Obviamente, esto puede generar archivos muy grandes en el momento de la compilación (bload de coad), por lo que debe considerar cuidadosamente si se necesita un #include.

En un diseño de archivo de código estándar donde tiene un archivo .h para una clase con las declaraciones de clase y función, y luego un archivo de implementación .cpp, debe tener cuidado con la cantidad de #includes que van en el archivo de encabezado. Esto se debe a que, cada vez que realice un cambio en el archivo de encabezado, también deberá recompilarse cualquier archivo que también lo incluya (es decir, que use su clase); si el encabezado en sí tiene muchas inclusiones, cada archivo que usa la clase se hincha de manera significativa en el momento de la compilación.

Es mejor usar declaraciones directas siempre que sea posible, para que pueda escribir las firmas de métodos, etc. y luego # incluya los archivos relevantes en el archivo .cpp para que pueda usar las clases y estructuras de las que depende su código.

//In myclass.h
class UtilClass; //Forward declaration of UtilClass - avoids having to #include untilclass.h here

class MyClass
{
    MyClass();
    ~MyClass();

    void DoSomethingWithUtils(UtilClass *util); //This will compile due to forward declaration above
};

//Then in the .cpp
#include utilclass.h

void MyClass::DoSomethingWithUtils(UtilClass *util)
{
    util->DoSomething(); //This will compile, because the class definition is included locally in this .cpp file.
}

Answer 8

Consulte la discusión sobre el uso de #include<filename.h> y #include<filename> para C ++ incluye las bibliotecas de C.

Answer 9

Utiliza #include "yourfile.h" si yourfile.h está en el directorio de trabajo actual y #include <yourfile.h> si la ruta de acceso a yourfile.h archivo yourfile.h se incluyó en los directorios de inclusión de C ++ (en algún lugar de la configuración, por ejemplo: c:/mylib/yourfile.h , la ruta c:/mylib/ debe especificarse como un directorio de inclusión) También puede incluir .cpp y .hpp (h plus plus). Hay un conjunto particular de archivos que se pueden escribir como: #include <iostream> . Para esto, para un trabajo de ejemplo particular, debe especificar el using namespace std;

Hay un software muy bueno que se integra con Microsoft Visual C ++, y muestra las rutas de inclusión. http://www.profactor.co.uk/includemanager.php