C++類的交叉引用

對於C++中，兩個類中相互引用對方，當然只能是在指針的基礎上，於是我們知道。也就是說在A類的有一個指針引用B類的成員函數或成員對象，而B類中又有一個指針來訪問A中的成員函數或對象。這就是C++中類的交叉引用編譯於。那如何解決這個問題呢？
當然方法很多，但是我一般采用的方法就是聲明與實現的分離。
也就是說類中的成員函數我們只在類中聲明，然后函數的實現要放到另一個文件中去。
主要是在類中的交叉引用時候，存在一個誰先誰后的問題，也就是說假如A類中用B的指針引用了B的一個成員函數，如果B中沒有引用A的成員，那問題好辦，我們先在A類的頭文件中引用B的頭文件，於是我們保證先編譯B，然后再編譯A。
但是我們如果在B中也有一個A的指針引用了A的成員函數呢？
那么是先編譯A還是先編譯B呢？ 如果先編譯A，那么A中引用了B的成員函數，B還沒編譯呢！ 如果先編譯B，而B中又引用了A的成員函數呢！
這樣就想當於死鎖或者不停地迭代。那么如何解決呢？
方法就是先聲明，再定義。直接看我們的解決方法：

---

class Observer(Observer.h)

  
  
  
          

   
   
   
           
#ifndef OBASER_H
   
   
   
           
#define OBASER_H
   
   
   
           
#include"Observerable.h"
   
   
   
           
class Observerable;
   
   
   
           
class Observer{
   
   
   
           
private:
   
   
   
           
    Observerable *subject_;
   
   
   
           
public:
   
   
   
           
    virtual void update(){};
   
   
   
           
    void observer(Observerable *s);
   
   
   
           
    ~Observer();
   
   
   
           
};
   
   
   
           
#endif
  
  
  
          

class Observerable(Observerable.h)

   
   
   
           

    
    
    
            
#ifndef OBASERVERABLE_H
    
    
    
            
#define OBASERVERABLE_H
    
    
    
            
#include<iostream>
    
    
    
            
#include<vector>
    
    
    
            
#include<algorithm>
    
    
    
            
class Observer;
    
    
    
            
class Observerable{
    
    
    
            
private:
    
    
    
            
    std::vector<Observer*> obsPtrs;
    
    
    
            
public:
    
    
    
            
    void register_obs(Observer *obs_);
    
    
    
            
    void unregister_obs(Observer *obs);
    
    
    
            
    void notificate_obs();
    
    
    
            

    
    
    
            
};
    
    
    
            
#endif
   
   
   
           

我們可以看到在兩個類中，對對方都加了一次聲明如：
class Observer
class Observerable
這里我們只是告訴編譯器，我們有這么一個類存在，不是一般的錯誤或者什么重定義亂定義之類的。

---

然后在另兩個文件中加類的成員函數的實現代碼：

Observer.cpp

    
    
    
            

     
     
     
             
#include"Observer.h"
     
     
     
             
#include"Observerable.h"
     
     
     
             
void Observer::observer(Observerable *s){
     
     
     
             
    s->register_obs(this);
     
     
     
             
}
     
     
     
             
 Observer::~Observer(){
     
     
     
             
    subject_->unregister_obs(this);
     
     
     
             
}
    
    
    
            

Observerable.cpp

     
     
     
             

      
      
      
              
#include"Observerable.h"
      
      
      
              
#include"Observer.h"
      
      
      
              
 void Observerable::notificate_obs(){
      
      
      
              
    for(int i=0;i<obsPtrs.size(); i++){
      
      
      
              
        if(obsPtrs[i]){
      
      
      
              
            obsPtrs[i]->update();
      
      
      
              
        }
      
      
      
              
     }
      
      
      
              
}
      
      
      
              
void Observerable::register_obs(Observer *obs_){
      
      
      
              
        obsPtrs.push_back(obs_);
      
      
      
              
    }
      
      
      
              
void Observerable::unregister_obs(Observer *obs){
      
      
      
              
    std::vector<Observer*>::iterator obsIter;
      
      
      
              
    if((obsIter=std::find(obsPtrs.begin(),obsPtrs.end(),obs))!=obsPtrs.end()){
      
      
      
              
        obsPtrs.erase(obsIter);
      
      
      
              
    }
      
      
      
              
}
     
     
     
             

而且在兩個具體實現的文件中如Observerable.cpp和Observer.cpp中，我們都分別引用了對方的頭文件，這回我們就得知道對方類的
成員函數有哪些了，以及其函數接口。

來自為知筆記(Wiz)