pushing an array to a function in c++? - c++

Question

{
int a[3];
mainClassStack.pushNumber(a[1,2,3]);
break;
}
void stack_class::pushNumber(int numberFunc)
{
if(head==NULL)
{
head = new stack_struct;
head->number = numberFunc;
head->next_number = NULL;
tailPointer=head;
}
else
{
pointerFunc = new stack_struct;
pointerFunc->number=numberFunc;
pointerFunc->next_number=NULL;
head->next_number=pointerFunc;
head=pointerFunc;
}
}
void stack_class::pushNumber(char charFunc)
{
int a=0;
a=charFunc;
if(head==NULL)
{
head = new stack_struct;
head->number = a;
head->next_number = NULL;
tailPointer=head;
}
else
{
pointerFunc = new stack_struct;
pointerFunc->number=a;
pointerFunc->next_number=NULL;
head->next_number=pointerFunc;
head=pointerFunc;
}
}
void stack_class::pushNumber(int arrayFunc[3])
{
if(head==NULL)
{
for(int i=0;i<3;i++)
{
head = new stack_struct;
head->number = arrayFunc[i];
head->next_number = NULL;
tailPointer=head;
}
}
else
{
for(int i=0;i<3;i++)
{
pointerFunc = new stack_struct;
pointerFunc->number=arrayFunc[i];
pointerFunc->next_number=NULL;
head->next_number=pointerFunc;
head=pointerFunc;
}
}
}
I am overloading functions and pushing an array into the appropriate function which will later add the values from the arrays to a dynamic linked list. So far I have written this, but when I try to print the linked list, it shows garbage. What am I doing wrong here?

Answer 1

Does this make more sense to you?
void Foo(int arg[])
{
printf("%i\n", arg[0]);
printf("%i\n", arg[1]);
printf("%i\n", arg[2]);
}
int main()
{
int a[3] = {1,2,3};
Foo(a);
return 0;
}
Output is:
1
2
3

Answer 2

To make more clear what others are pointing out, the comma operator returns the last value in the series. The value of the expression (1, 2, 3) is therefore 3, and so the expression a[1, 2, 3] is nothing more than a long way of saying a[3].
But there's something else that looks goofy right away, which is this loop here:
if(head==NULL)
{
for(int i=0;i<3;i++)
{
head = new stack_struct;
head->number = arrayFunc[i];
head->next_number = NULL;
tailPointer=head;
}
}
You point head to a new thing, set a couple things inside it, and then set tailPointer to point to that same new thing...but then immediately do the same two more times. Do you see the problem? At the end of the loop, you've created three items whose next_number values are all NULL, and head and tailPointer both point to the same thing: the last one created. You have nothing at all pointing to the first two items you created, and none of them point to each other. In other words, there is no linked list at all at the end of this operation (although there are a few new objects lying out there in memory somewhere with no way to access or de-allocate them).
You probably mean to have your if statement inside your loop, rather than the other way around, but you need to change more than just that, because the code in the other for loop might be a little problematic as well. It creates a new item, then sets up a link from the head item to the new one, but then it moves the head to point to the new one, so you are successfully adding an item to the tail of the list, but leaving yourself with a head variable that is actually pointing at the tail.
I suggest the best way to see what's going on is to take a pencil and paper, write down your variables and draw boxes to represent your objects, with their member variables inside, then step-by-step follow your code, writing in variable values or erasing and drawing arrows from the pointers to show where each one lands. I think you'll immediately see where your algorithm is going awry.

Answer 3

C++ does not allow to pass an entire array as an argument to a function. However, You can pass a pointer to an array by specifying the array's name without an index.
If you want to pass a single-dimension array as an argument in a function, you would have to declare function formal parameter in one of following three ways and all three declaration methods produce similar results because each tells the compiler that an integer pointer is going to be received.
Way-1
Formal parameters as a pointer as follows:
void myFunction(int *param)
{
.
.
.
}
Way-2
Formal parameters as a sized array as follows:
void myFunction(int param[10])
{
.
.
.
}
Way-3
Formal parameters as an unsized array as follows:
void myFunction(int param[])
{
.
.
.
}