Dependent variables in C++?

I tried asking before but I wasn't very clear so I'm re-asking it.

I want to have a variable that depends on the value of another variable, like b in this example:

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
}

Of course, this does not exist in C++, but this is what I want.

So instead I tried making a function:

int main(){开发者_如何学Go
    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
}

The above doesn't work because C++ doesn't allow nested functions.

I can only make functions outside of main(), like this:

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();
}

But this does not work because a is not in the same scope as b(), so I would have to pass a as a parameter and I don't want to do that.

Are there any tricks to get something similar to a dependent variable working in C++?

What you need is a closure. If you can use C++ 0x features, you are in luck. Otherwise, you can define one manually:

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

You can also define B inside main, but some compilers would not like it.

The C++ 0x lambda syntax looks like this:

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

The [&] means that the lambda captures local variables by reference.

If you're using C++0x (GCC 4.5+, Visual C++ 2010), you can use lambdas:

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

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

Depending on what you're doing, though, there are probably cleaner solutions - possibly some variation of the classic "method that takes in 'a' and returns 'b'"

You could define a class that had a member a, and then a function b() that returned the value of a+1. A basic implementation would be something like:

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();
}

You could add operator overloading as appropriate to make it work more like normal integers if you so desired.

This is possible if you use lambda functions (c++0x), because they can capture local variables.

Example:

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

Result:

4
5

(See http://ideone.com/MlzX7 for proof)

A simple approach is to use pre-processor macros, nothing C++ specific about it though:

#define b ((a)+1)

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

#undef b

Are you OK using C++0x ? if yes,

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

Since, it is not tagged with c++0x, you can use nested classes instead of nested functions. This column from Herb sutter would help you for existing c++. http://www.gotw.ca/gotw/058.htm

The above doesn't work because C++ doesn't allow nested functions.

You can simulate that using nested structure. In C++0x you can make use of lambda function, which provides the same means of function inside function.

Define a class called LinkedInt or something that behaves like an int, but has a RelatedTo relationship on itself and an additional member that is a function pointer to the function to evaluate when computing the integer's value. Pretty straightforward. Let me know if you need some pointers on the coding.

The short answer is that OOP is more than enough to bury this problem.

I want to have a variable that depends on the value of another variable, like b in this example:

I see you just need a reference variable:

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

Why C++0x lambdas do come for this, I dont understand.