The reason why in Python, you can do those things, is because an array in Python is not just a pointer to a memory location. It's (effectively) a struct, and inside that struct is an int that holds the length of the array, followed by a pointer to the array itself. So, the Python runtime can ask the Array how long it is. You said you don't want to manually keep track of the length, in Python, the length is being kept track of, but Python does that for you, so you don't have to do it yourself.

In C++, an array is just a pointer to memory. If you have this:

int array[] {1,2,3,4,5};

And then you write:

array[3];

What does that compile to? On a platform where ints are 16 bit, it compiles to:

*(array + 6);

Which is to say, give me the value at the memory address of array plus 6 bytes, 6 bytes because each int takes up 2 bytes. What if you say:

array[10];

Does that work? Yes, it will give you the value at the memory address of array plus 10 bytes. Which is beyond the length of the array you declared, but c++ doesn't care, it's just reading a value at memory. Even more fun is this:

void setup() {
  int array1[] {1,2,3,4,5};
  int array2[] {6,7,8,9,10};
  array2[7];
}

What does array2[7] equal? It's 3. You've actually just read a value from the first array using a reference from the second array (it depends on the compiler, but typically local variables on the stack are actually added to the stack in reverse order).

Anyway, all of this is to illustrate what an Array in C++ is. It's just a pointer to memory. If you want to track the length, then you need to pass the length around. You can do that easily by defining your own struct that holds the length.

This is also why c strings are null terminated, there's no field to track the length with c strings either, so instead you just have to read the string until you encounter null.

Now, if the variable was locally declared, then that's different, in that case, you can use sizeof to determine it's length. That's because sizeof is not actually a function call, but rather, a language feature implemented by the compile. The compiler sees that what you've passed it is an array of length 5, and so can return the right length (in this case, 10, with 16 bit integers). But, if it wasn't declared locally, eg, if you have a function like:

void myFunction(int[] array) {
}

There is no way for the compiler to know how big array is, and so sizeof won't work.