C constexpr constructor initializes garbage values-CodePudding

I wanted a simple class which would encapsulate a pointer and a size, like C 20's std::span will be, I think. I am using C (g 11.2.1 to be precise)

I want it so I can have some constant, module-level data arrays without having to calculate the size of each one.

However my implementation 'works' only sometimes, dependent on the optimization flags and compiler (I tried on godbolt). Hence, I've made a mistake. How do I do this correctly?

Here is the implementation plus a test program which prints out the number of elements (which is always correct) and the elements (which is usually wrong)

#include <iostream>
#include <algorithm>
using std::cout;
using std::endl;

class CArray {
 public:
  template <size_t S>
  constexpr CArray(const int (&e)[S]) : els(&e[0]), sz(S) {}
  const int* begin() const { return els; }
  const int* end() const { return els   sz; }
private:
  const int* els;
  size_t sz;
};
const CArray gbl_arr{{3,2,1}};

int main() {
  CArray arr{{1,2,3}};
  cout << "Global size: " << std::distance(gbl_arr.begin(), gbl_arr.end()) << endl;
  for (auto i : gbl_arr) {
    cout << i << endl;
  }
  cout << "Local size: " << std::distance(arr.begin(), arr.end()) << endl;
  for (auto i : arr) {
    cout << i << endl;
  }
  return 0;
}

Sample output:

Global size: 3
32765
0
0
Local size: 3
1
2
3

In this case the 'local' variable is correct, but the 'global' is not, should be 3,2,1.

CodePudding user response：

I think the issue is your initialization is creating a temporary and then you're storing a pointer to that array after it has been destroyed.

const CArray gbl_arr{{3,2,1}};

When invoking the above constructor, the argument passed in is created just for the call itself, but gbl_arr refers to it after its life has ended. Change to this:

int gbl_arrdata[]{3,2,1};
const CArray gbl_arr{gbl_arrdaya};

And it should work, because the array it refers to now has the same lifetime scope as the object that refers to it.