¿Cuál es la sobrecarga del tiempo de ejecución static_cast si se agrega constante mientras se mantiene el mismo tipo?
Me resulta irritante que pueda llamar a funciones no constantes de un objeto si tengo un puntero a este objeto. No puedo permitir que el puntero sea un puntero constante porque también hay funciones no constantes que necesito llamar. Por lo tanto, mi única opción parece hacer static_casts para garantizar que la constness también funcione en punteros. Aquí hay un ejemplo 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;
};
Sin embargo, me pregunto si static_cast tiene algún costo en tiempo de ejecución. ¿Las static_casts se evalúan por completo en el momento de la compilación o hay algo de sobrecarga, suponiendo que doNothing () se llame con frecuencia.
Editar: mi pregunta es diferente deC ++ static_cast runtime gastos generales porque en mi caso, static_cast solo agrega const. Otros usuarios que encuentren esta pregunta podrían estar interesados en la pregunta mencionada.