const baseado em função de sobrecarga através public/protected access

Question

(Eu acredito) eu sei sobre a sobrecarga de funções com base na constante de orelha a orelha:se o instante é constante, a constante é chamado de método, caso contrário, o não-const uma.

Exemplo (também em ideone):

#include <iostream>

struct S
{
  void print() const { std::cout << "const method" <<std::endl };
  void print()       { std::cout << "non-const method" <<std::endl };
};

int main()
{
  S const s1;
  s1.print(); // prints "const method"
  S s2;
  s2.print(); // prints "non-const method"
  return 0;
};

Eu tento/tentei fazer uso do que no meu código, mas teve alguns problemas quando o const métodos sobrecarregados não tem a mesma categoria de acesso.Ele pode ser mau estilo, mas aqui está um exemplo que reflete a idéia de voltar referências para evitar a cópia e utilização de const para limitar as alterações não intencionais:

struct Color;
struct Shape
{
  double area;
};

class Geometry
{
public:
  // everybody can alter the color of the geometry, so 
  // they get a mutable reference
  Color& color() { return m_color; };

  // not everybody can alter the shape of the Geometry, so
  // they get a constant reference to the shape.
  Shape const& shape() const { return m_shape; };

protected:
  // derived classes can alter the shape, so they get 
  // access to the mutable reference to alter the shape.
  Shape & shape() { return m_shape; };

private:
  Shape m_shape;
  Color m_color;
};

O problema que eu estou enfrentando agora é que eu quero o compilador para pegar o público, constretornar a forma de função, se alguma outra função mexe com as Geometrias, dizer a cor deles pela sua área, para que este seria necessário para aceder a forma da Geometria:

// this one fails
void colorByArea() {
  for( Geometry g : geometryList )
  { g.color() = colorMap[g.shape().area]; }
}

// this one is a clunky workaround
void colorByArea() {
  for( Geometry g : geometryList )
  { 
    Geometry const& g_const = g;
    g.color() = colorMap[g_const.shape().area];
  }
}

Este (ou algo semelhante) falha com a seguinte bastante compreensível de erro:

‘Shape& Geometry::shape()’ is protected 
  Shape & shape() { return m_shape; };

^ error: within this context
  g.color() = colorMap[g.shape().area];

(Eu coloquei um pouco simplificado não compilar o exemplo em ideone.)

Eu recebo (um grau) por que isso é happeding:g não é const e, portanto, a não-const forma(), que é protectec, é supostamente para ser chamado -, mas que, obviamente, falha.

Então eu acho que a minha PERGUNTA é:Existe uma maneira de obter algum tipo de "cair" para uma constante-função, se um não-const função não é acessível?

Answer 1

Existe uma maneira de obter algum tipo de "cair" para uma constante-função, se um não-const função não é acessível?

Não;resolução de sobrecarga ocorre antes da verificação de acesso.

Este não é apenas mau estilo;é um mau design.Um público função getter é conceitualmente diferentes a partir de uma função protegida que permite que código com conhecimento de internos modificar o objeto interno do estado.Em geral, as duas funções não precisa mesmo ter relacionadas com tipos de retorno.Portanto, eles não devem ter o mesmo nome.

Answer 2

Você pode usar const_cast para permitir a chamada de constante de versão como:

int main()
{
  S s2;
  const_cast<const S&>(s2).print(); // prints "const method"
  return 0;
};

Mas seria melhor/mais simples para mudar o nome do método.