Arrays passed to function in C++ giving different lengths - c++

Question

I want to say first - I'm as interested in what's happening "behind the scenes" to cause this problem as I am in a blind fix for the code. Perhaps the C++ standard or something I'm unfamiliar with dictates what's causing it :-)
Anyways...
I am trying to pass 3 arrays, A, B, C into a function, which will merge A and B, storing the result in C.
Function declaration: void merge(int* a, int* b, int* c)
Passed from main() by:
int A[] = {1,2,3,4};
int B[] = {6,7,8,9};
int* C; //this could be wrong, btw!
merge(A, B, C);
Issue 1.
What's strange is that in main(), if I print the result of sizeof(A)/sizeof(A[0]), it gives me the proper result for the "length" of the array - 4 - and the same thing for B. But when I pass the arrays to the function, I try to calculate the size again, by the same method, but I get the result 2 for both arrays. The first lines of merge():
void merge(int* a, int* b, int* c)
{
int sizeA = sizeof(a)/sizeof(a[0]);
int sizeB = sizeof(b)/sizeof(b[0]);
int totalsize = sizeA + sizeB;
std::cout << "size A = " << sizeA << std::endl; //prints 2
std::cout << "size B = " << sizeB << std::endl; //prints 2
std::cout << "total = " << totalsize << std::endl;
...
Issue 2.
Just for fun, I tried iterating through a and b passed to merge() (within the merge function):
for (int i = 0; i < 4; ++i)
std::cout << a[i]; //prints "1234" as expected
All cool. But when I increase the index limit to 8...
for (int i = 0; i < 8; ++i)
std::cout << a[i]; //prints "12346789" - A and B concatenated!
Raising the max index a couple more times because why not:
for (int i = 0; i < 10; ++i)
std::cout << a[i]; //prints "1234678900"
...
for (int i = 0; i < 11; ++i)
std::cout << a[i]; //prints "1234678900-444896443"
Undefined behavior from out of bounds indexing and accessing other memory, I guess.
Printing b in the same manner does similar:
looping to i = 4 prints the array - 6789
to 6 adds two zeroes - 678900
to 8 adds the other stuff - 678900-126926969126613
Printing C, of course, results in nothing.
Are these oddities the result of
the fact I'm using C++ Shell (with options -std=c++14 -Wpedantic -O2) ?
incorrect passing of arrays to merge() ?
incorrect initializations in main() ?
the arrays needing to have a terminator, like char arrays?
all of the above?

Answer 1

In the first case, you have an array, which is not the same as a pointer. So the sizeof is correctly computed. Whereas int* is a pointer, and an array passed to a function always decays to a pointer (except when passing by reference). Also sizeof(int*)/sizeof(int) is the size of the pointer on your machine divided by the size of the int, so if your system is a 64 bit (8 bytes) and the int has a typical size of 4, you get 8/4=2.
Typical undefined behaviour by indexing out of bounds.
Advice: use std::vector<int> instead and you'll avoid allocating memory for C and using sizeof. You can simply use the std::vector::size() member function to obtain the size of the vector.

Answer 2

When you are passing your array to void merge(int* a, int* b, int* c)
The a and b here are no longer arrays, but are pointers. So when you are calculating it's size using
int sizeA = sizeof(a)/sizeof(a[0]);here sizeof(a)will give you the size of pointer, and sizeof(a[0]is giving you the size of int. Hence the result.
And for your second issue, when you are increasing the indexes, and getting both arrays connected, it is just because both arrays have been allocated continuous memory block, it is not necessary though that they will always be assigned continuous memory blocks, and other outputs are because of Undefined behavior only.

Answer 3

you need to remember that sizeof is a keyword that expands in compile time to the relevant size. sizeof(T) will expand to the byte size of (T).
inside the main function, sizeof(a) will give you the number of bytes of int[4], inside different function, the array decays into a pointer. sizeof(T*) is not sizeof(T[4])! you are calculating the size of the pointer (after the decay) and not the size of the real array. now let say my object weight 1 MB, does sizeof(OBJ) == sizeof(OBJ*)? of course not.
you are having Undefined beaviour. in this specific example, A and B sit right after the another on the stack. so in this super specific case when iterating over the stack you actually print both of the arrays because they sit one after the another. but again , this is Undefined beaviour. different compilers can padd the area between the array, or other OS may even kill your program.

Answer 4

You cannot compute a size of an array with a simple pointer passed to a function.
sizeof(integers) / sizeof(integers[0])
will be simply replaced by
sizeof(pointer on integer) / sizeof(integer).
But you can compute it earlier and then pass the size to a function like below.
#include <iostream>
using namespace std;
void doSomeWork(int* integers, const size_t size)
{
for (size_t i = 0; i < size; ++i)
{
std::cout << integers[i] << std::endl;
}
}
int main()
{
int integers[] { 0, 1, 2, 3 };
const size_t size = sizeof(integers) / sizeof(integers[0]);
doSomeWork(integers, size);
return 0;
}
As said below, std::vector<int> is much better than playing with C arrays.

Answer 5

There are already plenty of good answers here. In short, C++ arrays are of fixed size. If you want to change it, you have to use pointers and dynamic allocation. That can be tedious. the reason for most people here to advise you to use vectors instead.
Vectors are build for being of dynamic and adjustable size. You can use them almost like arrays. Here your code adapted:
void merge(vector<int> &a, vector<int>& b, vector<int> &c) // pass by reference
{
int sizeA = a.size();
int sizeB = b.size();
int totalsize = sizeA + sizeB;
c.resize(totalsize); // easy !
// ...
}
int main() {
vector<int> A{1,2,3,4};
vector<int> B {6,7,8,9};
vector<int> C;
cout <<A[2]<<endl; // access elements exacly like arrays
merge(A, B, C);
}