Une forme plus simple de bouton

Question

Pourquoi ne pas choisir ce design:

// 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); }

Au lieu de celui-ci:

// 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){}
};

Puis-je masquer les détails de l'implémentation et accélérer la compilation avec des variables et des fonctions statiques définies dans le fichier source?Sinon, qu'est-ce qui ne va pas avec cette conception (à part l'héritage)?

Answer 1

Si vous utilisez des vecteurs globaux pour stocker l'état comme vous le proposez, vous devrez en quelque sorte vous assurer que différentes instances de la classe A utilisent différentes parties du vecteur (en plus des difficultés évidentes de le faire, considérez à quel point cela devient plus difficile sidifférents threads utilisent différentes instances de A).Cette conception n'a beaucoup de sens que si A est un singleton.

Answer 2

Dans le premier cas, il n'y a qu'une seule instance de impl_database_for_do_something pour l'ensemble du programme.Vous en voulez une par instance de A. Donc, le code n'est en aucun cas équivalent.

Answer 3

Votre première conception a un vecteur pour toutes instances de A;ce dernier a une instance par .Renseignez-vous sur les variables d'instance par rapport aux variables de classe.

Answer 4

Ce n'est pas du tout PIMPL: Pointer to IMPLementation.

Vous pouvez le faire de cette façon:

// 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);
}