Code Splitting dans des fichiers en-têtes/Source

Question

Je pris le code suivant à partir de la page d'exemples sur Asio

class tcp_connection : public boost::enable_shared_from_this<tcp_connection> 
{ 
public: 
    typedef boost::shared_ptr<tcp_connection> pointer; 

    static pointer create(boost::asio::io_service& io_service) 
    { 
    return pointer(new tcp_connection(io_service)); 
    } 

    tcp::socket& socket() 
    { 
    return socket_; 
    } 

    void start() 
    { 
    message_ = make_daytime_string(); 

    boost::asio::async_write(socket_, boost::asio::buffer(message_), 
     boost::bind(&tcp_connection::handle_write, shared_from_this(), 
      boost::asio::placeholders::error, 
      boost::asio::placeholders::bytes_transferred)); 
    } 

private: 
    tcp_connection(boost::asio::io_service& io_service) 
    : socket_(io_service) 
    { 
    } 

    void handle_write(const boost::system::error_code& /*error*/, 
     size_t /*bytes_transferred*/) 
    { 
    } 

    tcp::socket socket_; 
    std::string message_; 
}; 

Je suis relativement nouveau pour C++ (à partir d'un arrière-plan C#), et de ce que je comprends, la plupart des gens diviserait ceci en en-tête et en fichiers source (déclaration/implémentation, respectivement). Y at-il une raison pour laquelle je ne peux pas simplement le laisser dans le fichier d'en-tête si je vais l'utiliser dans de nombreux fichiers source? Si oui, y a-t-il des outils qui vont automatiquement le convertir en déclaration/implémentation pour moi? Quelqu'un peut-il me montrer à quoi cela ressemblerait divisé en en-tête/fichier source pour un exemple (ou juste une partie de celui-ci, de toute façon)? Je suis confus autour de choses étranges comme ça typedef boost::shared_ptr<tcp_connection> pointer; Dois-je inclure cela dans l'en-tête ou la source? Idem avec tcp::socket& socket()

J'ai lu beaucoup de tutoriels, mais cela a toujours été quelque chose qui m'a rendu confus au sujet de C++.

Answer 1

Fractionnement cela pourrait ressembler à ceci:

// in the header-file 
class tcp_connection : public boost::enable_shared_from_this<tcp_connection> 
{ 
public: 
    typedef boost::shared_ptr<tcp_connection> pointer; 

    static pointer create(boost::asio::io_service& io_service); 
    tcp::socket& socket(); 
    void start(); 
private: 
    tcp_connection(boost::asio::io_service& io_service); 
    void handle_write(const boost::system::error_code& /*error*/, 
     size_t /*bytes_transferred*/); 

    tcp::socket socket_; 
    std::string message_; 
}; 

// in the cpp-file 

// #using the namespace in which the class was declared here 

tcp_connection::pointer tcp_connection::create(boost::asio::io_service& io_service) 
    { 
    return pointer(new tcp_connection(io_service)); 
    } 

    tcp::socket& tcp_connection::socket() 
    { 
    return socket_; 
    } 

    void tcp_connection::start() 
    { 
    message_ = make_daytime_string(); 

    boost::asio::async_write(socket_, boost::asio::buffer(message_), 
     boost::bind(&tcp_connection::handle_write, shared_from_this(), 
      boost::asio::placeholders::error, 
      boost::asio::placeholders::bytes_transferred)); 
    } 

    tcp_connection::tcp_connection(boost::asio::io_service& io_service) 
    : socket_(io_service) 
    { 
    } 

    void tcp_connection::handle_write(const boost::system::error_code& /*error*/, 
     size_t /*bytes_transferred*/) 
    { 
    } 

En fait, toutes les implémentations de la méthode ont été déplacés dans le fichier cpp. typedef boost::shared_ptr<tcp_connection> pointer;defines an alias for a type et reste dans l'en-tête. Pour comprendre la logique des classes de fractionnement, recherchez here et here. Pour comprendre les raisons de ne pas le faire, regardez here. Une raison pour ne pas séparer les deux précédentes est que vous n'avez pas besoin de lier quoi que ce soit pour utiliser la classe. Vous devez seulement inclure l'en-tête. J'espère que cela vous donne un point de départ.

Answer 2

avec des modèles, il est très typique de les implémenter directement dans le fichier d'en-tête.

C'est probablement la solution la plus simple aux problèmes de liaison qui peuvent apparaître si vous essayez d'implémenter les fonctions de modèle dans un fichier cpp.

voir ce faq pour plus d'informations.

Answer 3

Vous pouvez diviser le code d'une classe de modèles en un fichier d'implémentation, vous incluez ce fichier à l'adresse et de votre fichier d'en-tête. ACE (Adaptive Communication Framework) utilise cette procédure fortement. Par conséquent, je vous recommande de vérifier.