Qual é a sobrecarga do tempo de execução static_cast se você adicionar uma constante mantendo o mesmo tipo?
Acho irritante poder chamar funções não constantes de um objeto se tiver um ponteiro para esse objeto. Não posso deixar que o ponteiro seja um ponteiro const, porque também há funções não-const que preciso chamar. Portanto, minha única opção parece fazer static_casts para garantir que a constância também funcione entre ponteiros. Aqui está um exemplo mínimo:
class MyClassImpl
{
MyClassImpl(void) : m_i(0) {}
int increment(void) {
++m_i;
return m_i;
}
private:
int m_i;
};
class MyClass
{
MyClass(void) : m_pImpl(new MyClassImpl()){}
~MyClass(void) {
delete m_pImpl;
}
int doNothing(void) const {
m_pImpl->increment(); // works although MyClassImpl::increment() is non-const
// static_cast<const MyClassImpl *>(m_pImpl)->increment(); // this will not compile because of non-constness
}
private:
MyClass(const MyClass & rhs);
MyClassImpl * m_pImpl;
};
No entanto, gostaria de saber se o static_cast tem algum custo em tempo de execução. Os static_casts são completamente avaliados em tempo de compilação ou há alguma sobrecarga, supondo que doNothing () seja chamado com freqüência.
Editar: minha pergunta é diferente deSobrecarga de tempo de execução static_cast do C ++ porque no meu caso, o static_cast adiciona apenas const. Outros usuários que encontrarem essa pergunta podem estar interessados na pergunta mencionada.