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

operador de resolucion de ambito c++

Question

(En C ++) Tengo una clase cuya estructura se declara en un archivo de encabezado. Ese archivo de encabezado se incluye en muchos archivos de origen, de modo que cuando lo edito necesito recompilar muchos archivos.

La clase tiene un conjunto de funciones privadas que solo se llaman en un archivo fuente. Actualmente están declarados en la estructura de clase en el archivo de encabezado. Cuando agrego una nueva función de este tipo, o edito los argumentos, por lo tanto, causa una 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 conseguir esto?

Answer 1

¿Está buscando un cortafuegos de compilador , también conocido como PIMPL?

Answer 2

Cree una clase base abstracta que contenga solo las funciones públicas y haga referencia a esto en sus encabezados. Crea tu clase real como una implementación en otro lugar. Solo los archivos de origen que necesitan crear su clase necesitan ver el encabezado de la clase de implementación.

Answer 3

No hay forma de declarar funciones miembro de una clase fuera de la declaración de clase principal. Por lo tanto, 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, 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, deberá colocarlas en una nueva clase y hacer de la clase original un amigo 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 4

Use el lenguaje pImpl : su clase visible mantiene un puntero a la clase real y reenvía las llamadas a las funciones de miembro público.

EDITAR: 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(); }

Mantenga la implementación real de su clase en FooImpl : Foo debería tener copias de los miembros públicos de FooImpl y simplemente reenviar las llamadas 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 ningún cambio.