Question

My colleague recently compiled our program in Windows, and discovered a bug of the sort:

  std::string a = "hello "; 
  std::string b = "world"; 
  const char *p = (a+b).c_str();
  printf("%s\n", p);

which for some reason did not crash in our Linux executables.

None of our compilers give any kind of warning, so we are now worried that this error might exist in the code.

Although we can grep for c_str() occurrences and do a visual inspection, there is a possibility that one might have also done the following:

struct I {
     int num;
     I()   { num=0; }
};

struct X { 
     I *m;
     X()  { m = new I; }
     ~X() { delete m; }
     I  get() { return *m; }   // version 1, or
     I& get() { return *m; }   // version 2
};

and accessed it like:

  I& a = X().get();         // will get a reference to a temporary, or a valid copy?
  cout << a.num;

instead of :

 cout << X().get().num;   

which is safe (isn’t it?)

Question: Is there a way I can catch such errors (perhaps using the compiler, or even an assertion) ?
I need to be sure that if author of struct X changes get() between version 1 and 2 that the program will warn for the error

Answer 1

Check out this question’s solution, I think it does something similar to what you’re looking for:

C++ catching dangling reference

There are runtime based solutions which instrument the code to check
invalid pointer accesses. I’ve only used mudflap so far (which is
integrated in GCC since version 4.0). mudflap tries to track each
pointer (and reference) in the code and checks each access if the
pointer/reference actually points to an alive object of its base type.
Here is an example: {…}