c++ - ¿Hay algún truco ninja para hacer que una variable sea constante después de su declaración?

c++11 const-correctness

Question

Sé que la respuesta es 99.99% no, pero pensé que valía la pena intentarlo, nunca se sabe.

void SomeFunction(int a)
{
    // Here some processing happens on a, for example:
    a *= 50;
    a %= 10;
    if(example())
       a = 0;
    // From this point on I want to make "a" const; I don''t want to allow
    // any code past this comment to modify it in any way.
}

Puedo hacer algo similar con const int b = a; , pero en realidad no es lo mismo y crea mucha confusión. Una solución solo C ++ 0x es aceptable.

EDIT : otro ejemplo menos abstraído, el que me hizo hacer esta pregunta:

void OpenFile(string path)
{
    boost::to_lower(path);
    // I want path to be constant now
    ifstream ...
}

EDITAR : otro ejemplo concreto: Recuperar la constidad de las variables en una sección paralela .

Answer 1

¿Por qué no refactorizar su código en dos funciones separadas? Uno que devuelve un a modificado y otro que funciona con este valor (sin cambiarlo nunca).

También podría envolver su objeto alrededor de un objeto de clase de soporte y trabajar con este soporte.

template <class T>
struct Constify {
    Constify(T val) : v_( val ) {}
    const T& get() const  { return v_; }
};

void SomeFuncion() {
    Constify ci( Compute() ); // Compute returns `a`
    // process with ci
}

Su ejemplo tiene una solución fácil: refactorización.

// expect a lowercase path or use a case insensitive comparator for basic_string
void OpenFile(string const& path)  
{        
    // I want path to be constant now
    ifstream ...
}

OpenFile( boost::to_lower(path) ); // temporaries can bind to const&

Answer 2

Claro, no hay forma de hacerlo usando el mismo nombre de variable en C ++.

Answer 3

En realidad, no sugiero hacer esto, pero podrías usar sombras variables creativas para simular algo como lo que quieres:

void SomeFunction(int a)
{
    // Here some processing happens on a, for example:
    a *= 50;
    a %= 10;
    if(example())
       a = 0;
    {
        const int b = a;
        const int a = b;  // New a, shadows the outside one.
        // Do whatever you want inside these nested braces, "a" is now const.
    }
}

Answer 4

Puede mover el código para generar a en otra función:

int ComputeA(int a) {
  a *= 50;
  a %= 10;
  if (example())
    a = 0;
  return a;
}

void SomeFunction(const int a_in) {
  const int a = ComputeA(a_in);
  // ....
}

De lo contrario, no hay una buena manera de hacerlo en tiempo de compilación.

Answer 5

Un patrón que solía utilizar es "ocultar" el argumento con un _, por lo que el código se convierte

void SomeFunction(int _a)
{
    // Here some processing happens on a, for example:
    _a *= 50;
    _a %= 10;
    if(example())
       _a = 0;

    const int a = _a;
    // From this point on I want to make "a" const; I don''t want to allow
    // any code past this comment to modify it in any way.
}

También puede usar solo variables const y hacer una función para calcular el nuevo valor de a, si es necesario. Tiendo más en más para no "reutilizar" variables en hacer lo más posible mis variables inmutables: si cambias el valor de algo, entonces dale un nombre nuevo.

void SomeFunction(const int _a)
{
    const int a = preprocess(_a);
    ....

}

Answer 6

Una solución sería factorizar todo el código de mutación en una expresión lambda. Haga toda la mutación en la expresión lambda y asigne el resultado a un const int en el alcance del método. Por ejemplo

void SomeFunction(const int p1) { 
  auto calcA = [&]() {
    int a = p1;
    a *= 50;
    a %= 10;
    if(example())
       a = 0;
    ..
    return a;
  };
  const int a = calcA();
  ...
}

Answer 7

esta podría ser una forma de hacerlo, si solo está tratando de evitar otro nombre. te sugiero que lo pienses dos veces antes de usar esto.

int func ()
{
    int a;
    a %= 10;

const int const_a = a;
#define a const_a

    a = 10;  // this will cause an error, as needed.
#undef a
}