Why array of references not allowed in C++

By the way the language is designed, a reference is an alias to something else and must be initialized on instantiation.
But the language doesn't provide any mechanism to initialize array elemets all together.

The only possible way should be a sort of language extension allowing things like

int a,b,c;
int& v[] = { a, b, c };
// v[0] aliases a, v[1] does b and v[2] does c.

But that's not feasible being a b & c not constant.

Look here:
Similar discussion - 1[^]
MSDN speaks...[^]

You are trying to declare intArrayOfRefs as a reference and also as an array, which makes no sense. A reference is an alias to an existing object, not an object itself. Try stepping through something like the following code in your debugger to see how the references are addressed.

int anInt = 10;          // a simple integer
int *aPointer = &anInt;  // pointer to the integer
int* &refPointer = aPointer;  // reference (alias) to pointer
*anInt = 10;             // set value of anInt
*refPointer = 5;         // change the same variable's value

You also seem to be confusing a reference with the addressof operator; not surprising really.

I think you should do like this:

//The Compile Environment is Visual Studio 2008
//array p is the reference of array a

#include <iostream>
using namespace std;

int main()
{  
	int a[]={1,2,3};
	const int length=sizeof(a)/sizeof(int);//length must be const
	int (&p)[length]=a;
	for(int i=0;i<length;++i)>
	{
		cout<<p[i];
		if(i!=length)
		{
			cout<<' ';
		}
	}
	cout<<endl;
	return 0;
}
</iostream>

Good Luck, For your information.

Hi,

With reference to knowledge on arrays and references concept i am attempting to answer
the question you asked "Why array of references not allowed in c++". This is just theoretical
& assumption which i am giving.

As we know array is combination of similar data types in a continuous memory,that means
consider the following statement,

int a[4];

Here, with assumption that starting address is 0x1000,

as per array definition,

a[0] will store at 0x1000,
a[1] will store at 0x1004,
a[2] will store at 0x1008,
a[3] will store at 0x1012,

As per definition of reference, its an alias to existing variable, which internally coveys that the address of reference and the aliased variable is same. In that situation if
you consider an array of references as follows,
int a,b,c,d;
int& a[4] = {a,b,c,d};

The memory allocation for this reference view will be as follows again,

a[0] will store at 0x1000 which is alias of a;
a[1] will store at 0x1004 which is alias of b;
a[2] will store at 0x1008 which is alias of c;
a[3] will store at 0x1012 which is alias of d;

As per reference definition a[0] and a should have same address location, and
a[1] and b should have same address location, and so on.... which may not be possible always
as we are not guaranteed that the memory locations of variables which are aliased by array of reference may not be in continuous memory.

From the above assumption we can clearly tell that the array of references are not allowed as we are not guaranteed the address of variables which are aliased by array.

Thank you,

Satya
(I am not perfect, i am making this explanation with assumption and basics of array and references)