🔒 Locked

passing a struct array in a function as refence... ?

Started by Alpha Brain Jul 11, 2007 at 12:52 PM 25 replies 12.6k views

Original Post

Jul 11, 2007 at 12:52 PM


#include <iostream>
#include <string>

using namespace std;

struct COORD
{
	int x;
	int y;
};

void set_zero(COORD &n[])
{
	for(int i=0; i<5; i++)
	{
		n.x = 0;
		n.y = 0;
	}
}

void main(void)
{
	COORD c[5];

	for(int i=0; i<5; i++)
	{
		c.x = 10;
		c.y = 10;
	}

	set_zero(c);
}

error: error C2234: '' : arrays of references are illegal it seems that arrays of references are illegal... Then what is the possible way to pass an array of data with references or pointers? Thanks!

ToohrVyk

Jul 11, 2007 at 12:54 PM

It's mainly an operator priority thing (and also, you're missing the array size: arrays in C have a fixed size that is embedded in the type).

void set_zero(int (&n)[5]) {}

Alpha Brain

Jul 11, 2007 at 12:58 PM

thanks!

is there a recommended website where I could learn more about operator priority?

Alpha Brain

Jul 11, 2007 at 1:06 PM

(me again)

mmmm even if the syntax is okay for the compilor, the values isn't returning from the parameter...

#include <iostream>#include <string>using namespace std;struct COORD{	int x;	int y;};void set_zero(COORD (&n)[5]){	for(int i=0; i<5; i++)	{		n.x = 0;		n.y = 0;	}}void main(void){	COORD c[5];	for(int i=0; i<5; i++)	{		c.x = 10;		c.y = 10;		cout << "c[" << i << "].x = " << c.x << endl;		cout << "c[" << i << "].y = " << c.x << endl << endl;	}	cout << "---------------------------------------------------------" << endl;	cout << "CALL FUNCTION TO SET ALL COORDS FROM ARRAY TO ZERO       " << endl;	cout << "---------------------------------------------------------" << endl;	set_zero(c);	// test to see if coords are really to zero.	for(i=0; i<5; i++)	{		c.x = 10;		c.y = 10;		cout << "c[" << i << "].x = " << c.x << endl;		cout << "c[" << i << "].y = " << c.x << endl << endl;	}}

asdfg__12

Jul 11, 2007 at 1:10 PM

http://www.cppreference.com/operator_precedence.html

here you can find the info you want.

Alternatively you could just pass a COORD* pointer. The name of an array is a pointer to it's first element, so you can do this:

#include <iostream>void print(int *array, int size){	std::cout << array[13] << std::endl;};int main(){	int array[14] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};		print(array, 14);	};

EDIT: you actually reset the values to 10 after calling set_zero and before reprinting them :P Careful when copy-pasting :P

swiftcoder

Jul 11, 2007 at 1:11 PM

In this example, there is no need to pass the array by reference. Don't forget that arrays in C are really *just* pointers (extra syntax non-withstanding), so any function passed an array can modify the array's contents.
You only need to pass a reference to an array if you need the function to change the array pointer itself (i.e. pointing it at another buffer), and that doesn't work for static arrays.

Alpha Brain

Jul 11, 2007 at 1:24 PM

anyone could take my code please and bring changes to it? would really help me to understand by seeing the difference...

EDIT: AHHHHHHHHHHHHHHHHHHH! I'm stupid! really stupid!!!

lol

I've reassigned the value to 10 again after calling the set_zero function.

it's what we call "danger of copy/pasting code" lol

ToohrVyk

Jul 11, 2007 at 1:33 PM

Quote:
Original post by swiftcoder
In this example, there is no need to pass the array by reference. Don't forget that arrays in C are really *just* pointers (extra syntax non-withstanding), so any function passed an array can modify the array's contents.
You only need to pass a reference to an array if you need the function to change the array pointer itself (i.e. pointing it at another buffer), and that doesn't work for static arrays.

Arrays have size information while pointers don't (you cannot determine how many elements a pointer can iterate through). Arrays decay to a pointer to their first element when evaluated in a pointer context, which loses their size information. Passing an array by reference conserves the type information. You cannot change what the array represents (an array is a sequence of elements, it doesn't point to one). Dynamic arrays are generally an incorrect or approximate denomination, the only arrays in C and C++ are static-sized ones, the rest is either pointer to buffers or container classes.

rip-off

Jul 11, 2007 at 1:36 PM

Quote:
Original post by swiftcoder
In this example, there is no need to pass the array by reference. Don't forget that arrays in C are really *just* pointers (extra syntax non-withstanding), so any function passed an array can modify the array's contents.

Arrays decay to pointers, arrays are not pointers.

Quote:

You only need to pass a reference to an array if you need the function to change the array pointer itself (i.e. pointing it at another buffer), and that doesn't work for static arrays.

If you pass a reference to an array, you can use sizeof on the array and not get sizeof(pointer).

However the OP might find he is better served by using std::vector or boost::array.

swiftcoder

Jul 11, 2007 at 2:26 PM

Quote:
Original post by rip-off
Quote:
Original post by swiftcoder
In this example, there is no need to pass the array by reference. Don't forget that arrays in C are really *just* pointers (extra syntax non-withstanding), so any function passed an array can modify the array's contents.

Arrays decay to pointers, arrays are not pointers.

nitpicker :)
If I declare 'char A[5]', A is a pointer. Albeit to a either the static data section or to a region on the stack, and immutable.

Quote:
Quote:
You only need to pass a reference to an array if you need the function to change the array pointer itself (i.e. pointing it at another buffer), and that doesn't work for static arrays.

If you pass a reference to an array, you can use sizeof on the array and not get sizeof(pointer).

But in fact that is just a syntactical issue, and you *have* created an unnecessary temporary pointer. And are you quite sure about that? I am not near a compiler to test that, but it seems to me you should get the same result whether you pass an array, or a reference to an array (note that I never mentioned using a pointer directly).

Quote:
However the OP might find he is better served by using std::vector or boost::array.

Most likely.

swiftcoder

Jul 11, 2007 at 2:51 PM

It looks as if several posters may have confused the terms 'array', 'pointer', and 'reference' in this context.

// 1) This function takes an array as an argumentvoid funcArray(char arg[5]);// 2) This one takes a pointervoid funcPointer(char *arg);// 3) And this on etakes a *reference* to an arrayvoid funcRefArray(char (&arg)[]);// 4) and finally... this one takes a reference to a pointervoid funcRefPointer(char *(&arg));

I never mentioned the pointer variants, I was talking about 1) and 3), and pointing out that in either the fnction can modify the array contents.

rip-off

Jul 11, 2007 at 2:53 PM

Quote:
Original post by swiftcoder
Quote:
Original post by rip-off
Quote:
Original post by swiftcoder
In this example, there is no need to pass the array by reference. Don't forget that arrays in C are really *just* pointers (extra syntax non-withstanding), so any function passed an array can modify the array's contents.

Arrays decay to pointers, arrays are not pointers.

nitpicker :)
If I declare 'char A[5]', A is a pointer. Albeit to a either the static data section or to a region on the stack, and immutable.

Nope. A is a C++ symbol. When the compiler translates the code to an exectable format "A" no longer exists. Its value is an array. &A == &A[0]. With a pointer &Pointer != &Pointer[0]. sizeof(A) == Num bytes in array. sizeof(Pointer) == the size of an address on the targer platform. A cannot be reseated, Pointer could be made point to some other variable.

The fact that arrays decay to pointers means that many properties of pointers are conceptually shared by arrays but they are not the same.

Quote:
Quote:
Quote:
You only need to pass a reference to an array if you need the function to change the array pointer itself (i.e. pointing it at another buffer), and that doesn't work for static arrays.

If you pass a reference to an array, you can use sizeof on the array and not get sizeof(pointer).

But in fact that is just a syntactical issue, and you *have* created an unnecessary temporary pointer. And are you quite sure about that? I am not near a compiler to test that, but it seems to me you should get the same result whether you pass an array, or a reference to an array (note that I never mentioned using a pointer directly).

I see no temporary pointer. Maybe at underlying levels the compiler will choose to use this to implement the code, but we are not writing code at that level.
I believe you are incorrect, unless I'm misinterpreting you. You will get different results.

ToohrVyk

Jul 11, 2007 at 3:00 PM

Quote:
Original post by swiftcoder
If I declare 'char A[5]', A is a pointer. Albeit to a either the static data section or to a region on the stack, and immutable.

No.

The address of an array variable is the address of its contents. This is unlike pointers, the address of which is irrelevant, but the value of which contains the address of something else.

The sequence of operations performed for accessing A[3] is:

Get the address of A, add 3, dereference (if A is an array).
Get the address of A, dereference, add 3, dereference (if A is a pointer).

That is, accessing a memory buffer through a pointer requires an additional dereference in order to access the value of the pointer, which is the address of the buffer.

Quote:
But in fact that is just a syntactical issue, and you *have* created an unnecessary temporary pointer. And are you quite sure about that? I am not near a compiler to test that, but it seems to me you should get the same result whether you pass an array, or a reference to an array (note that I never mentioned using a pointer directly).

When you pass a reference to an array, the type is conserved. Since the array size is encoded in the type, it is accessible to the compiler. On the other hand, you cannot pass an array by value in C and C++. The array automatically decays to a pointer if you do, and the size information is lost. The only way to conserve type information is using a reference:

#include <iostream>int byref(int (&a)[5]){  return sizeof(a);}int byval(int a[5]){  return sizeof(a);}int main(){  int a[5];  std::cout << byref(a) << std::endl << byval(a) << std::endl;}

Outputs:

rip-off

Jul 11, 2007 at 3:12 PM

Quote:
Original post by swiftcoder
It looks as if several posters may have confused the terms 'array', 'pointer', and 'reference' in this context.
*** Source Snippet Removed ***
I never mentioned the pointer variants, I was talking about 1) and 3), and pointing out that in either the fnction can modify the array contents.

This may be true, but when passing an array to a function declared using (1) arg *is* a pointer, this is due to C++ specifying that an array passed as an argument to a function will decay to a pointer. This is a singular point of confusion.

void example( char arg[] );void foo() {   char array[4] = {};   example(array); // array decays to a pointer   char *pointer = array;   example(pointer); // look we can pass a pointer directly   // this wont   // array++;   }void example( char arg[] ) {    // look what we can do now!    arg++;}

However, 99% of the time passing an array by reference will be the same as passing it by pointer decay, as it is rare for someone to use "array specific" things like the sizeof trick.

An useful example that can be achieved via reference but not via pointer decay is an array size template:

template< class T, int N >int array_size( T (&arg)[N] ) {   return N;}void bar( int arg[] );void foo() {    int array[5];    int x = array_size(array); // x == 5    bar(array); // wont work because...}void bar( int arg[] ) {   int x = array_size(arg); // ...no function to match array_size( int *& )}

SiCrane

Jul 11, 2007 at 3:43 PM

Quote:
Original post by ToohrVyk
The sequence of operations performed for accessing A[3] is:
Get the address of A, add 3, dereference (if A is an array).
Get the address of A, dereference, add 3, dereference (if A is a pointer).

Huh? Consider the functions:

int foo(int A[], int n) {  return A[n];}int bar(int * A, int n) {  return A[n];}

Here's the assembly MSVC 2003 generates for foo:

	mov	eax, DWORD PTR _n$[esp-4]	mov	ecx, DWORD PTR _A$[esp-4]	mov	eax, DWORD PTR [ecx+eax*4]	ret	0

Here's bar:

	mov	eax, DWORD PTR _n$[esp-4]	mov	ecx, DWORD PTR _A$[esp-4]	mov	eax, DWORD PTR [ecx+eax*4]	ret	0

Alpha Brain

Jul 11, 2007 at 5:01 PM

this thread have moved beyond the scope of my knowledge hehe
ok another question that may sound stupid to you;

#include <iostream>#include <string>using namespace std;void alter(string names[]){	names[0] = "zombie";	names[1] = "vampire";	names[2] = "mummy";	names[3] = "werewolf";	names[4] = "grim reaper";}void main(void){	string names[] = {"imp", "critter", "slime", "goblin", "troll"};	int i=0;	for(i=0;i<5;i++)	{		cout << names << endl;	}		cout << endl;	alter(names);	for(i=0;i<5;i++)	{		cout << names << endl;	}}

Now what do I do if I don't want the argument to be affected by the values inside the function? Since arrays seems to act like pointer, it's a tricky question for a beginner...

rip-off

Jul 11, 2007 at 5:20 PM

First, main returns an int, not void. The C++ Standard even specifies that you don't even need to write return in main, it will return 0 unless you explicitly return a different value.

Use std::vector. Its better than an array as it acts how you expect when you pass it to a function or return it from one:

#include <iostream>#include <vector>#include <string>using namespace std;// turns out I find a use for this example below =)template< class T, int N >int array_size( T (&arg)[N] ) { return N; }// because we didnt pass the vector by reference, the// vector in main will not be affectedvoid alter(std::vector<std::string> names){	names[0] = "zombie";	names[1] = "vampire";	names[2] = "mummy";	names[3] = "werewolf";	names[4] = "grim reaper";}int main(){	const char *names_data[] = {"imp", "critter", "slime", "goblin", "troll"};        // there is no easy way to initialise a std::vector directly        // currently this is about as easy as it gets        // in practise though such data will be loaded from        // an external source anyway        std::vector<std::string> names(data, data + array_size(data);	        // declare loop variables inside the for loop        // its much clearer        //int i=0;	for( int i = 0 ; i < names.size() ; i++ )	{		cout << names << endl;	}	cout << endl;	alter(names);	for( int i = 0 ; i < names.size() ; i++ )	{		cout << names << endl;	}}

Alpha Brain

Jul 11, 2007 at 5:34 PM

but without the vector, it isn't possible? (just want to understand the basic way first)

swiftcoder

Jul 11, 2007 at 7:39 PM

Quote:
Original post by Alpha Brain
but without the vector, it isn't possible? (just want to understand the basic way first)

You would have to allocate a new array, and copy the contents. C/C++ arrays can not be passed by value, so no matter how much you pass the 'handle' (basically a pointer) to the array around, each will refer to the same array.

Glak

Jul 11, 2007 at 8:10 PM

I think that this thread is a very strong argument for the use of std::vector instead of arrays. Arrays are far too complicated to be considered a basic language feature. I avoid their use as much as possible. When I do use an array it is either a local variable or I new[] some memory for use with a pointer. I would never write a function that takes an array as a parameter.

Topic Locked

This topic has been locked by a moderator. New replies are not allowed.