//определение
class C1{
public:
   void foo(){/*...*/}
};
//и
template <typename T>
class C2{
public:
   C2(T &Src):Ref(Src){}//в Ref храним ссылку на заданный объект
   void foo(){/*...*/}
   T &Ref;
};

//в главном cpp:
C1 c1;
C2<C1> c2_1(с1);
C2<C1> c2_2(с1);

A>//определение
A>class C1{
A>public:
A>   void foo(){/*...*/}
A>};
A>//и
A>template <typename T>
A>class C2{
A>public:
A>   C2(T &Src):Ref(Src){}//в Ref храним ссылку на заданный объект
A>   void foo(){/*...*/}
A>   T &Ref;
A>};

A>//в главном cpp:
A>C1 c1;
A>C2<C1> c2_1(с1);
A>C2<C1> c2_2(с1);
A>

void C1::foo()
{
 static bool flag;
 if(!flag)
 {
  flag = true;
  // делаем что надо 
 }
}

class C1
{
public:
 C1()
    : foo_called_(false)
 {
 }

 void foo()
 {
  if(!foo_called_)
  {
   foo_called_ = true;
   // DO
  }
 }

private:
 bool foo_called_;
};

C1 c1; // c1.foo_called == false
c1.foo(); // c1.foo_called == true
C1 c2; // c2.foo_called == false
c2.foo(); // c2.foo_called == true

// счётчик времени
typedef void const* event_t;
int next_tick(event_t event) // event - произвольный идентификатор события. Подряд идущие события сливаются, чтобы уменьшить риск перемотки
{
    static event_t last_event = NULL;
    static int last_tick = 0;
    
    if(last_event != event) { last_event = event; ++last_tick; }
    return last_tick;
}


class C1
{
public:
    int tick;
    void foo() { tick=next_tick(this); ...... }
};

class C2
{
    C1* link;
    int tick;
    void foo()
    {
        int diff = this->tick - link->tick;
        if(diff < 0)
            ..... // были вызовы link->foo() после последнего this->foo()
        tick=next_tick(this);
        .....
    }
};

struct history_t
{
    typedef void const* event_t;
    std::vector<event_t> frame; // окно истории (последовательность событий в порядке их возникновения)
    
    void add(event_t event) // встаём в хвост очереди (естественно, выбывая из середины)
    {
        frame.erase(std::find(frame.begin(),frame.end(),event));
        frame.push_back(event);
    }
    int find(event_t event) const // положение в очереди (от хвоста); 0 означает отсутствие
    {
        return std::distance(std::find(frame.begin(),frame.end(),event),frame.end());
    }
} history;


class C1
{
    void foo() { history.add(this); ..... }
};

class C2
{
    C1* link;
    void foo()
    {
        int linkpos = history.find(link), thispos = history.find(this);
        // (0..thispos) - отрезок между настоящим моментом и последним вызовом this->foo()
        if(linkpos>0 && linkpos<thispos)
            ... // где-то между ними был совершён link->foo()
        if(thispos==0 && linkpos!=0)
            ... // this->foo() вызывается в первый раз, а link->foo() уже был
        if(linkpos==0)
            ... // link->foo() вообще не вызывался
        .......
        history.add(this);
    }
};

//определение
class C1{
public:
   void foo()
   {
       for( i...)
          depends[i] = true;
       // DO
   }
   void create_dependency(ID){depends[ID] = false; }
   bool get_dependency(ID) {return depends[ID];// или false если в depends нет элемента ID}
private:
   map<ID,bool> depends;
};
//и
template <typename T>
class C2{
public:
   C2(T &Src):Ref(Src)
   {
      ID = ::GenerateC2ID();
      Ref.create_dependency(ID);
   }
   void foo()
   {
       if(Ref.get_dependency())
       {
          //DO
       }
   }
   T &Ref;
   ID;
};

//в главном cpp:
C1 c1;                 //depends пустой
c1.foo()
C2<C1> c2_1(с1);      // depends = {(1,false)}
c1.foo()              // depends = {(1,true)}
C2<C1> c2_2(с1);      // depends = {(1,true), (2,false) }
c1.foo()              // depends = {(1,true), (2,true) }

К>>class C2
К>>{
К>>    C1* link;
К>>    int tick;
К>>    void foo()
К>>    {
К>>        int diff = this->tick - link->tick;
К>>        if(diff < 0)
К>>            ..... // были вызовы link->foo() после последнего this->foo()
К>>        tick=next_tick(this);//кстати тут можно счетчик не накручивать,
К>>                     //а просто поменять last_event => не выйдем
К>>                     //за дозволеный диапазон int
К>>        .....
К>>    }
К>>};