Una forma más simple de PIMPL

Question

¿Por qué no elegir este diseño?

// A.hpp
class A
{
public:
    void do_something();
};

// A.cpp
#include "A.hpp"
#include <vector>

std::vector<int> impl_database_for_do_something;

static void impl_helper_for_do_something(const std::vector<int>& database){}

void A::do_something(){ impl_helper_for_do_something(impl_database_for_do_something); }

En lugar de este:

// A.hpp
#include <vector>
class A
{
public:
    void do_something();

private:
    std::vector<int> database_for_do_something_;
    void helper_for_do_something(const std::vector<int>& database){}
};

¿Podría ocultar los detalles de implementación y la compilación de aceleración con variables y funciones estáticas definidas en el archivo fuente? Si no, ¿qué tiene de malo este diseño (además de la herencia)?

Answer 1

Si usa vectores globales para almacenar el estado como propone, de alguna manera tendrá que asegurarse de que diferentes instancias de Clase A usen diferentes partes del vector (además de las dificultades obvias de hacerlo, considere cuánto más difícil se vuelve si se usan diferentes hilos diferentes instancias de a). Este diseño solo tiene mucho sentido si A es un singleton.

Answer 2

En el primer caso, solo hay una instancia de impl_database_for_do_something para todo el programa. Desea una instancia por instancia de A. para que el código no sea en ningún sentido equivalente.

Answer 3

Tu primer diseño tiene una vector para todos instancias de A; Este último tiene uno por instancia. Lea las variables de instancia frente a las variables de clase.

Answer 4

Esto no es, en absoluto, PIMPL: puntero a la implementación.

Podrías hacerlo de esta manera:

// A.hpp
#include <boost/shared_ptr.hpp>

class A
{
public:
  A();
  void foo();

private:
  struct Impl;
  boost::shared_ptr<Impl> _impl;
};

// A.cpp
#include <vector>
#include "A.hpp"

struct A::Impl {
  std::vector<int> _data;
};

A::A(): _impl(new std::vector<int>()) {}

void A::foo() {
  _impl->_data.push_back(3);
}

Advertencia: Este código no trata con el comportamiento de copia / asignación adecuado, se deja como un ejercicio para el lector.