Proteção dos membros protected

Quando queremos que um membro de nossa classe seja visível apenas dentro dos métodos da classe e dentro dos métodos das classes derivadas dessa classe usamos o nível de proteção protected. Isso, é claro, não quer dizer que uma classe derivada vá ter acesso aos membros protegidos de outra:

#include <iostream>

using namespace std;

class Base
{
protected:
	int m_protected;
};

class Deriv : public Base
{
public:
	int GetProtectedFromBase();
	int GetProtectedFromDeriv2();
};

class Deriv2 : public Base
{
};

int Deriv::GetProtectedFromBase()
{
	return m_protected;
}

int Deriv::GetProtectedFromDeriv2()
{
	Deriv2 deriv2;
  // error C2248: 'Base::m_protected' : cannot
  // access protected member
  // declared in class 'Base'
	return deriv2.m_protected;
}

int main()
{
	Deriv deriv;
	deriv.GetProtectedFromBase();
	deriv.GetProtectedFromDeriv2();
}

Esse é o motivo fundamental do porquê não podermos fazer isso:

int Deriv::GetProtectedFromBase()
{
  Base base;
  return base.m_protected;
}

Ao acessar membros protegidos é importante o tipo da expressão que está do lado esquerdo do "." ou "->". Afinal, o nível de proteção se baseia no escopo, e as classes são um escopo. É por isso que consigo acessar os membros protegidos de um outro objeto de minha classe, mesmo sendo outro objeto:

int Deriv::GetProtectedFromDeriv2()
{
  Deriv deriv;
  assert(typeid(deriv) == typeid(*this));
  return deriv.m_protected; // OK
}

A definição do escopo é tudo o que o compilador dispõe para saber se acessa ou não acessa um membro. Podemos ter acesso a m_protected enquanto somos do tipo Deriv, mas não quando o mesmo objeto é usado como Base:

int Deriv::GetProtectedFromBase()
{
  Base& base = *this;
  assert(typeid(base) != typeid(*this));
  return base.m_protected; // ERROR
}

Essa proteção parece desnecessária e até mesmo incoerente quando lidamos com o mesmo objeto que acessa. Afinal, somos nós mesmos! Só que o compilador não sabe disso, e ele deve desconfiar de tudo e de todos para evitar esse tipo de "ataque":

int Deriv::GetProtectedFromDeriv2()
{
  Deriv2 deriv2;
  Base& base = deriv2;
  assert(typeid(deriv2) != typeid(*this));
  return base.m_protected; // ERROR
}

Agora a proteção do compilador faz sentido. Parece um detalhe frívolo, mas já vi programadores de respeito se debatendo pela "burrice" do compilador. Imaginei que talvez houvesse mais pessoas com a mesma dúvida de se existe ou não um "bug na linguagem".