Evitar declarar funciones privadas en archivos de encabezado de clase (C++)

Question

(En C++) Tengo una clase cuya estructura se declara en un archivo de encabezado. Ese archivo de encabezado está incluido en muchos archivos fuente, de modo que cuando lo edite necesito recompilar muchos archivos.

La clase tiene un conjunto de funciones privadas que solo se llaman en un archivo fuente. Actualmente se declaran en la estructura de clases en el archivo de encabezado. Cuando agrego una nueva función de este tipo o edito los argumentos, por lo tanto, provoca la recompilación de muchos archivos. Me gustaría declarar las funciones en otro lugar, de modo que solo se recompile el archivo que las define y las llama (para ahorrar tiempo). Sin embargo, todavía necesitan poder acceder a las variables de clase internas.

¿Cómo puedo lograrlo?

Answer 1

No hay forma de declarar las funciones de miembro de una clase fuera de la declaración de clase principal. Entonces, si desea declarar, fuera de la clase en cuestión, las funciones que pueden acceder a las variables miembro de una instancia particular de la clase, entonces no veo otra alternativa que pasar esa instancia a la función. Además, si desea que las funciones puedan acceder a las variables privadas y protegidas, tendrá que ponerlas en una nueva clase y hacer que la clase original sea amiga de eso. P.ej.

header.h:

class FooImpl; 

class Foo { 
public: 
    int bar(); 
    friend class FooImpl; 
private: 
    int var; 
} 

impl.cpp:

#include "header.h" 

class FooImpl { 
public: 
    int bar(Foo &); 
} 

int FooImpl::bar(Foo &foo) { 
return foo.var; 
} 

int Foo::bar() { 
return FooImpl::bar(*this); 
} 

Answer 2

Use la pImpl idiom - Su clase visible mantiene un puntero a la clase real y reenvía las llamadas a las funciones miembro públicas.

EDIT: En respuesta a los comentarios

// Foo.h: 

class FooImpl; // Do *not* include FooImpl.h 
class Foo { 
public: 
    Foo(); 
    ~Foo(); 
    //.. also need copy ctor and op= 
    int bar(); 
private: 
    FooImpl * Impl; 
}; 

// FooImpl.h: 

class FooImpl { 
public: 
    int bar() { return Bar; } 
private: 
    int Bar; 
}; 

// Foo.cpp: 

#include "FooImpl.h" 

Foo::Foo() { Impl = new FooImpl(); } 
Foo::~Foo() { delete Impl; } 
int Foo::bar() { return Impl->bar(); } 

Mantener la implementación real de su clase en FooImpl - Foo debe tener copias de los miembros públicos de FooImpl y pide simplemente adelante a estos. Todos los usuarios incluirán solo "Foo.h". Puede cambiar todos los detalles privados de FooImpl sin que los usuarios de Foo vean los cambios.

Answer 3

¿Está buscando Compiler Firewall, a.k.a. PIMPL?

Answer 4

crear una clase base abstracta que contiene sólo las funciones públicas y la referencia de esto en sus cabeceras. Crea tu clase real como una implementación en otro lugar. Solo los archivos fuente que necesitan crear su clase necesitan ver el encabezado de la clase de implementación.