Is it expected that a function evaluation in a watch window is "eagerly" evaluated?

[TryerGit]

Consider the code such as: https://compiler-explorer.com/z/73jcz5P1Y

#include <vector>

class foo{
  std::vector<int> abc;
  int getabc(int indx){
    return abc[indx];
  }
  void putabc(int val){
    abc.push_back(val);
  }
};

int main(){
  std::vector<int> temp;
  {
    foo fooobject;
  }
}

Set a breakpoint on the first line of main. Run till there. On the watch window to the right, enter, say, fooobject.getabc(0). Then, step into the inner scope where fooobject is instantiated. Because fooobject has no valid getabc(0) at this stage, I immediately encounter the following error at runtime:

/usr/include/c++/13/bits/stl_vector.h:1148:34: runtime error: reference binding to null pointer of type 'const value_type

Note that this entry in the watch windows could be from a previous debugging session where indeed the watch was valid.

Is there a way to prevent this eager evaluation of watch entries? Visual Studio IDE, for instance, has a refresh button so that these evaluations can occur only when the user desires and not eagerly.

Thanks.

[sean-mcmanus]

@TryerGit If you can find any instance of VS Code not doing this (for other language debuggers) then I would say it's a bug or feature request. I see TypeScript do the same thing so it seems like there might not be support for the VS "refresh" behavior.

[TryerGit]

I see. Thanks for the response. The issue is that a crash / error / segfault on immediately entering a scope while debugging seems to suggest some bug in the program for the unwary user. It took me a while to get used to such behaviour and only now do I look at the watch window to see if there is any out of bound access, etc.