Question

我之前尝试过询问，但我不是很清楚，所以我重新询问它。

我希望有一个变量取决于另一个变量的值，例如本例中的b：

int main(){
    int a;
    dependent int b=a+1; //I'm just making this up
    a=3;
    cout << b; //prints 4
    a=4;
    cout << b; //prints 5
}

当然，这在C ++中不存在，但这就是我想要的。

所以我试着创建一个函数：

int main(){
    int a;
    int b(){ return a+1; } //error
    a=3;
    cout << b(); //would print 4 if C++ allowed nested functions
    a=4;
    cout << b(); //would print 5 if C++ allowed nested functions
}

上述方法不起作用，因为C ++不允许嵌套函数。

我只能在main（）之外创建函数，如下所示：

int b(){
    return a+1; //doesn't work because a is not in scope
}

int main(){
    int a;
    a=3;
    cout << b();
    a=4;
    cout << b();
}

但这不起作用，因为a与b（）的范围不同，所以我必须传递一个参数，我不想这样做。

是否有任何技巧可以获得类似于使用C ++工作的因变量？

Answer 1

您需要的是closure。如果你可以使用C ++ 0x功能，那么你很幸运。否则，您可以手动定义一个：

#include <iostream>
using namespace std;
struct B
{
    const int & a;

    B(const int & a) : a(a) {}

    // variable syntax (Sean Farell's idea)
    operator int () const { return a + 1; }

    // function syntax
    int operator () () const { return a + 1; }
};
int main()
{
    int a;
    B b(a);
    a = 3;
    cout << b << '\n'; // variable syntax
    a = 4;
    cout << b() << '\n'; // function syntax
}

您也可以在B内定义main，但有些编译器不喜欢它。

C++ 0x lambda语法如下所示：

auto b = [&]() { return a + 1; }

[&]表示lambda通过引用捕获局部变量。

Answer 2

如果您使用的是C ++ 0x（GCC 4.5 +，Visual C ++ 2010），则可以使用lambdas：

int a = 5;
auto b = [&a]{ return a + 1; };

std::cout << b() << std::endl;

根据你正在做的事情，可能有更清晰的解决方案 - 可能是一些经典“方法的变体，它接受'a'并返回'b'”

Answer 3

您可以定义一个具有成员a的类，然后定义一个返回值+ 1的函数b（）。基本实现类似于：

class Dependent {
public:
    Dependent(void) { m_value = 0; }
    void set(int value) { m_value = value; }
    int b(void) { return(m_value + 1); }
private:
    int m_value;
};


int main(){
    Dependent a;
    a.set(3);
    cout << a.b();
    a.set(4);
    cout << a.b();
}

如果您愿意，可以根据需要添加运算符重载，使其更像普通整数。

Answer 4

如果你使用lambda函数（c ++ 0x），这是可能的，因为它们可以捕获局部变量。

示例：

int main()
{
  int a;
  auto f = [&] () -> int { return a + 1; };
  a = 3;
  std::cout << f() << std::endl;
  a = 4;
  std::cout << f() << std::endl;
  return 0;
}

结果：

4
5

（见http://ideone.com/MlzX7提供证明）

Answer 5

一种简单的方法是使用预处理器宏，但没有特定于C ++的具体内容：

#define b ((a)+1)

int main(){
    int a;
    a=3;
    cout << b;
    a=4;
    cout << b;
}

#undef b

Answer 6

你还可以使用C ++ 0x吗？如果是的话，

int main()
{
    int a = 10;
    auto b = [&a]() -> int { return a + 1; };
    cout << b() << endl;
}

因为它没有用c ++ 0x标记，所以可以使用嵌套类而不是嵌套函数。 Herb sutter的这一专栏将帮助您使用现有的c ++。 http://www.gotw.ca/gotw/058.htm

Answer 7

上述方法不起作用，因为C ++不允许嵌套函数。

您可以使用嵌套结构模拟它。在C ++ 0x中，您可以使用lambda函数，它在函数内提供相同的函数方法。

Answer 8

定义一个名为LinkedInt的类或行为类似于int的类，但它本身具有一个RelatedTo关系，另一个成员是一个函数指针，指向计算整数值时要求的函数。非常直截了当。如果你需要关于编码的一些指示，请告诉我。

简短的回答是，OOP足以掩盖这个问题。

Answer 9

我想要一个取决于另一个值的变量变量，如本例中的b：

我看到你只需要一个参考变量：

int a;
int &b =a;
a=10;
cout << b; // 10

为什么C ++ 0x lambdas会为此而来，我不明白。

C ++中的因变量？

9 个答案: