是否有一些忍者技巧可以在声明后将变量设为常量？

Question

我知道答案是 99.99% 否，但我认为值得一试，你永远不会知道。

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.
}

我可以用 const int b = a; 做一些类似的事情，但它实际上并不相同，并且会造成很多混乱。仅 C++0x 的解决方案是可以接受的。

编辑：另一个不太抽象的例子，就是让我问这个问题的：

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

编辑：另一个具体的例子：重新捕获并行部分中变量的常量。

Answer 1

一种解决方案是将所有突变代码分解为 lambda 表达式。在 lambda 表达式中执行所有突变，并将结果分配给方法范围内的 const int 。例如

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

或者甚至

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

Answer 2

您可以将生成 a 的代码移至另一个函数中：

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);
  // ....
}

否则，没有好的方法可以在编译时执行此操作。

Answer 3

我曾经使用的一种模式是用 _ “隐藏”参数，因此代码变为

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.
}

You can also use only const variables 并创建一个函数来计算 a 的新值（如果需要）。我更倾向于不“重用”变量，并尽可能使我的变量不可变：如果您更改某些值，则给它一个新名称。

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

}

Answer 4

为什么不将代码重构为两个单独的函数。一个返回修改后的 a ，另一个则处理该值（不更改它）。

您也可以将您的对象包裹在持有者类对象周围并使用此持有者。

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
}

您的示例有一个简单的修复方法：重构。

// 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 5

如果您只是想避免使用另一个名称，这可能是一种方法。我建议你在使用这个之前三思而后行。

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
}

Answer 6

我实际上并不建议这样做，但您可以使用创意变量阴影来模拟您想要的东西：

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 7

答案非常可靠，但老实说，我真的想不出使用它的好情况。但是，如果您想预先计算一个常数，这基本上就是您正在做的事情，您有几种主要方法可以做这。

首先我们可以进行以下操作。因此编译器会简单地为我们设置 CompileA#，在本例中它是 50、100 和 150。

const int CompileA1 = EarlyCalc(1);
const int CompileA2 = EarlyCalc(2);
const int CompileA3 = EarlyCalc(3);

int EarlyCalc(int a)
{
    a *= 50;
    return a;
}

现在除了这个之外，还有很多方法可以处理这个问题。我喜欢这个建议，就像其他人提到的那样。

void SomeFunc(int a)
{
    const int A = EarlyCalc(a);
    //We Can't edit A.
}

但另一种方式可能是......

SomeFunc(EarlcCalc(a));

void SomeFunc(const int A)
{
    //We can't edit A.
}

或者甚至......

SomeFunction(int a)
{
    a *= 50;
    ActualFunction(a);
}

void ActualFunction(const int A)
{
    //We can't edit A.
}

Answer 8

当然，在 C++ 中没有办法使用相同的变量名来做到这一点。