सी ++, आपसी जरूरतों वाले दो वर्ग

Question

मैंने जावा से सी ++ में एक वैज्ञानिक सिमुलेशन प्लेटफॉर्म को परिवर्तित कर दिया है। मैंने पिछले कार्यान्वयन के जितना संभव हो सके डिजाइन को रखने की कोशिश की है। देर से बाध्यकारी के कारण जावा में, परिपत्र निर्भरताओं को रन टाइम पर हल किया जाता है। हालांकि, परिपत्र निर्भरताओं ने सी ++ में एक गड़बड़ी का नरक बनाया है।

1. क्या कोई स्वचालित उपकरण है जिसमें सर्कुलर का विश्लेषण और संदर्भ शामिल है और संदर्भ? (विजुअल स्टूडियो 2010 केवल बकवास त्रुटियों की एक बड़ी सूची जारी करता है)।

2. मैंने जहां भी संभव हो आगे संदर्भों का उपयोग करने की कोशिश की है। हालांकि कुछ अवसरों में दोनों वर्गों को अन्य वर्ग की कार्यक्षमता की आवश्यकता होती है (यानी उन तरीकों पर कॉल करें जो आगे संदर्भ का उपयोग करना असंभव बनाता है)। ये जरूरत तर्क में मौजूद हैं और यदि मैं मूल रूप से डिजाइन को बदलता हूं तो वे वास्तविक दुनिया के अंतःक्रियाओं का प्रतिनिधित्व नहीं करेंगे।

   हम दो वर्गों को कैसे कार्यान्वित कर सकते हैं जिन्हें एक-दूसरे के तरीकों और स्थिति की आवश्यकता होती है? क्या उन्हें सी ++ में लागू करना संभव है?

उदाहरण:

• उदाहरण 1: मैं एक वर्ग "विश्व" कहा जाता है जो प्रकार "एजेंट" की वस्तुओं बनाता है। एजेंट को अपने पर्यावरण की जानकारी प्राप्त करने के लिए विश्व विधियों को कॉल करने की आवश्यकता है। दुनिया को एजेंटों के माध्यम से पुन: प्रयास करने और अपनी "रन" विधि निष्पादित करने और उनकी स्थिति प्राप्त करने की आवश्यकता है (समस्या के इस खंड को हल करने के लिए स्थिति अद्यतन संभवतः विपरीत किया जा सकता है लेकिन रन विधि नहीं)।
• उदाहरण 2: एजेंट अपने "इरादों" का संग्रह बनाते हैं। प्रत्येक एजेंट को अपने इरादों के माध्यम से पुन: प्रयास करने और अद्यतन/अद्यतन/इरादे की स्थिति पढ़ने की आवश्यकता होती है। इरादों को एजेंट के माध्यम से पर्यावरण के बारे में जानकारी प्राप्त करने की भी आवश्यकता है (अगर सीधे "विश्व" के माध्यम से किया जाता है तो यह जटिल सर्कल बना देगा) और एजेंट की जानकारी भी।

आरेख नीचे वर्गों में से एक उप सेट दिखाता है, और अपने तरीके और गुण के कुछ:

Answer 1

मैं नहीं देख रहा हूं कि आगे की घोषणाएं आपके लिए कैसे काम नहीं कर रही हैं।

World.h:

#ifndef World_h 
#define World_h 

class Agent; 

class World 
{ 
    World(); 
    void AddAgent(Agent* agent) { agents.push_back(agent); } 
    void RunAgents(); 
private: 
    std::vector<Agent*> agents; 
}; 

#endif 

Agent.h:

#ifndef Agent_h 
#define Agent_h 

class World; 
class Intention; 

class Agent 
{ 
    Agent(World& world_): world(world_) { world.AddAgent(this); } 
    status_t Run(); 
private: 
    World& world; 
    std::vector<Intention*> intentions; 
}; 

#endif 

World.cc:

#include "World.h" 
#include "Agent.h" 

void World::RunAgents() 
{ 
    for(std::vector<Agent*>::iterator i = agents.begin(); i != agents.end; ++i) 
    { 
     Agent& agent(**i); 
     status_t stat = agent.Run(); 
     // do something with stat. 
    } 
} 

// ... 

एजेंट ऐसा लगता है कि आप की तरह कुछ की जरूरत है लग रहा है।सीसी:

#include "Agent.h" 
#include "World.h" 
#include "Intention.h" 

// ... 

Answer 2

आप केवल आगे घोषणाओं के साथ समस्या को हल कर सकते हैं, लेकिन आप शायद 'नहीं था वर्ग की घोषणा से कार्यान्वयन को अलग नहीं करते हैं।

यदि आपको कक्षा से विधियों को कॉल करने की आवश्यकता है, तो एक पूर्ण प्रकार की आवश्यकता है, यही कारण है कि आपको फ़ाइल को शामिल करने की आवश्यकता है। सर्कुलर निर्भरताओं के बारे में चिंता किए बिना आप फ़ाइल को cpp (कार्यान्वयन फ़ाइल) में शामिल कर सकते हैं।