class A {
public:
    void process() {}
};

class B {
public:
    B(const A* a)
        : m_a(a)
    {}
    
    const A* getA() const {return m_a;}
private:
    const A* m_a;
};

void f(const std::vector<A*>& aa, const B& b) {
    // Известно, что указатель хранящийся в b так же содержиться и в aa.
    // Нужно сделать так:
    b.getA()->process(); // Ошибка! b.getA() возвращает const A*, а нужно A*
}

class A
{
public:
  int GetID() const;
  void process() {}
};

class B
{
public:
  B(const A* a)
    : m_a(a)
  {}

  int GetA_ID() const
  {
    return m_a->GetID();
  }

private:
  const A* m_a;
};

void f(const std::vector<A*>& aa, const B& b)
{
  aa.findByID(b.GetA_ID())->process();
}

АЕ>Это фрагмент кода более сложной программы. На самом деле вектор нам доступен как член данных того же класса, которому принадлежит и фукнция f.


АЕ>const не может стоять не по делу — программа не будет компилироваться. А вот нехватка вполне возможна.

Ещё как может стоять не по делу. Убери все const из программы — и она снова станет компилироваться так что это не аргумент.

Если ты знаешь, что объект A, переданный в B, нужно [i]будет

assert( std::find(aa.begin(), aa.end(), b.getA()) != aa.end() );
const_cast<A*>(b.getA())->process();

std::cout << controller.theModel()->fooItem()->barItem()->buzItem()->name(); // можно
controller.theModel()->fooItem()->barItem()->buzItem()->process(); // нельзя
controller.pleaseModify( controller.theModel()->fooItem()->barItem()->buzItem() ); // можно
anotherController.pleaseModify( controller.theModel()->fooItem()->barItem()->buzItem() ); // нужно дать по пальцам

class A {
public:
    void process() {}
};

class B {
public:
    B(const A* a)
        : m_a(a)
    {}
    
    const A* getA() const {return m_a;}
private:
    const A* m_a;
};


class C {
public:
    void process() {
        m_b.getA()->process(); // Ошибка! m_b.getA() возвращает const A*, а нужно A*
    }
private:    
    std::vector<A> m_aa;
    B m_b;
};

A * nonConst = &m_aa[0] + (m_b.getA() - m_aa[0]);

АЕ>class A {
АЕ>private:
АЕ>  void process() {}
     friend class C;
АЕ>};
АЕ>

class AforC
{
protected: // потому что для класса A это тоже можно
  void process(); // только для класса C, и больше ни для кого
  friend class C;
};
class AforD
{
protected:
  void perform();
  friend class D;
};
class A: public AforC, public AforD {};

class AforC
{
protected:
  friend class A;
  friend class AforD;
  friend class C;
  void process();
};

class AforD
{
protected:
  friend class A;
  friend class D;
  void perform();
};

class A: public AforC, public AforD
{
public:
  void execute() { process(); perform(); } // можно инлайнить, ибо объявления выше
};

// а эти определения вынесены из объявления классов
inline void AforC::process() { static_cast<A*>(this)->perform(); }
inline void AforD::perform() { static_cast<A*>(this)->execute(); }

template<class A> class AforC
{
protected:
  friend class AforD;
  friend class C;
  void process() { static_cast<A*>(this)->perform(); }
};

template<class A> class AforD
{
protected:
  friend class A;
  friend class D;
  void perform() { static_cast<A*>(this)->execute(); }
};

class A: public AforC<A>, public AforD<A>
{
public:
  void execute() { process(); perform(); } // можно инлайнить, ибо объявления выше
};