¿Qué son las declaraciones forward en C++?

Por qué forward-declare es necesario en C++

El compilador quiere asegurarse de que no ha cometido errores ortográficos o pasado el número incorrecto de argumentos a la función. Por lo tanto, insiste en que primero ve una declaración de 'add' (o cualquier otro tipo, clase o función) antes de que se use.

Esto realmente solo permite que el compilador haga un mejor trabajo de validación del código, y le permite ordenar los cabos sueltos para que pueda producir un archivo objeto de aspecto ordenado. Si no tener que reenviar declarar cosas, el compilador produciría un archivo objeto que tendría que contener información sobre todas las conjeturas posibles en cuanto a lo que la función 'add' podría ser. Y el enlazador tendría que contener una lógica muy inteligente para tratar de averiguar qué 'add' realmente pretende llamar, cuando la función 'add' puede vivir en un archivo de objeto diferente el enlazador se une con el que utiliza add para producir un dll o exe. Es posible que el enlazador pueda obtener el add incorrecto. Dime quería usar int add(int a, float b), pero accidentalmente olvidó escribirlo, pero el enlazador encontró un int add(int a, int b) ya existente y pensó que era el correcto y lo usó en su lugar. Tu código se compilaría, pero no estaría haciendo lo que esperabas.

Por lo tanto, solo para mantener las cosas explícitas y evitar las adivinanzas, etc., el compilador insiste en declarar todo antes de que se use.

Diferencia entre declaración y definición

Como un aparte, es importante saber la diferencia entre una declaración y una definición. Una declaración simplemente da suficiente código para mostrar cómo se ve algo, por lo que para una función, este es el tipo devuelto, llamando a convención, nombre del método, argumentos y sus tipos. Pero el código para el método no es necesario. Para una definición, necesita la declaración y luego también el código para la función.

Cómo las declaraciones forward pueden reducir significativamente los tiempos de construcción

Usted puede conseguir el declaración de una función en su corriente .cpp o .archivo h # incluyendo el encabezado que ya contiene una declaración de la función. Sin embargo, esto puede ralentizar su compilación, especialmente si #incluye una cabecera en a.h en lugar de .cpp de su programa, como todo lo que #incluye .h que estás escribiendo terminaría # incluyendo todas las cabeceras que escribiste # incluye para también . De repente, el compilador #ha incluido páginas y páginas de código que necesita compilar incluso cuando solo quería utilice una o dos funciones. Para evitar esto, puede usar una declaración forward y simplemente escriba la declaración de la función usted mismo en la parte superior del archivo. Si solo estás usando unas pocas funciones, esto realmente puede hacer que tus compilaciones sean más rápidas en comparación con always #incluyendo el encabezado. Para proyectos realmente grandes, la diferencia podría ser una hora o más de tiempo de compilación reducido a unos pocos minutos.

Romper referencias cíclicas donde dos definiciones usan cada una los demás

Además, las declaraciones forward pueden ayudarle a romper los ciclos. Aquí es donde dos funciones tratan de usarse entre sí. Cuando esto sucede (y es una cosa perfectamente válida), puedes #incluir un archivo de cabecera, pero ese archivo de cabecera intenta #incluir el archivo de cabecera que estás escribiendo actualmente.... que #incluye el otro encabezado, que #incluye el que estás escribiendo. Estás atrapado en una situación de gallina y huevo con cada archivo de encabezado tratando de re #incluir el otro. Para resolver esto, puede reenviar-declarar las partes que necesita en uno de los archivos y dejar el #include fuera de ese archivo.

Eg:

Coche de Archivo.h

#include "Wheel.h"  // Include Wheel's definition so it can be used in Car.
#include <vector>

class Car
{
    std::vector<Wheel> wheels;
};

Rueda de Archivos.h

Hmm... la declaración de Coche se requiere aquí como Rueda tiene un puntero a un coche, pero el coche.h no se puede incluir aquí, ya que resultaría en un error del compilador. Si Coche.h fue incluido, que luego trataría de incluir la rueda.h que incluiría Coche.h que incluiría Rueda.h y esto continuaría para siempre, por lo que en su lugar el compilador genera un error. La solución es reenviar declarar Coche en su lugar:

class Car;     // forward declaration

class Wheel
{
    Car* car;
};

Si la rueda de clase tenía métodos que necesitan llamar a métodos de car, esos métodos podrían definirse en Rueda.cpp y Rueda.cpp ahora es capaz de incluir Coche.h sin causar un ciclo.