所谓数组引用，即指向数组的引用；
 
 如    int   a[10] ;    
 
     　int   (&b)[10] = a ;
 
 如果写成　int   a[10] ;
 
               　 int* &b = a ;
 
 将会报错： cannot convert from 'int [10]' to 'int *&'。
 
 　　或许你会说在数组名不就是指向这个数组的一个指针吗？题中a是int*类型的，b是指向int*的引用，按理应该是正确的啊，为什么会报错呢？这是因为编译器对指向数组的引用检查更加严格，需要检查数组的维数，在这里a被理解成指向10个int数组的指针int [10]，对于引用也需要相应的引用类型int (&)[10]，即指向10个int数组的指针的引用。
 

  c和c++中有一个“数组降价”问题。
 

  #include <iostream>
 

  void test( char arr[100] )
 
 {
 
      std::cout << sizeof(arr) << std::endl ; // 输出 4
 
 }
 

  int main()
 
 {
 
     char arr[100] = { 0 };
 
     std::cout << sizeof(arr) << std::endl; // 输出 100　
 
     test( arr );
 
 
 
     return 0 ;
 
 }
 

  这段代码的输出是100
 
                             4
 
 
 
       对于同样的arr,一个输出100，另一个输出4。是因为void test( char arr[100] )中的arr被降价了。
 

  void test( char arr[100] ) 中的arr被降阶处理了，
 
        void test( char arr[100] ) 等同于void test( char arr[] )， 也等同于
 
 　　void test( char* const arr ) 如果你原意，它甚至等同于
 
 　　void test( char arr[10] )
 
 　　编译器对数组的维数不作检查。
 

  也就是说
 
 void test( char arr[100] )
 
 {
 
      std::cout << sizeof(arr) << std::endl;
 
 }
 
 
 
 被降成
 
 void test( char* const arr )
 
 {       std::cout << sizeof(arr) << std::endl; // 既然是char*，当然输出4
 
 }     这样，即然不检查数组的大小，对于需要保证数组大小的程序就会带来问题。如何解决这个问题呢？可以用c++中的对数组的引用。
 
 看下面这段代码：
 

  ......
 

  void test( const char (&arr)[100] )
 
 {
 
      std::cout << sizeof(arr) << std::endl ; // 输出 100
 
 }
 

  ......
 
     char arr[100] = { 0 };
 
     std::cout << sizeof(arr) << std::endl; // 输出 100　
 
     test( arr );
 
 ......
 

  这样test就能接受100个char的数组，且只能接受大小为100的char数组
 

  如果
 
 　　char　arr[20] = {0};
 
        test( arr ) ;
 
 就会报错
 

  　　在C++ 中，对数组的引用可以直接传递数组名，因为数组的大小的信息已在形参里提供了。但是这样一来我们只能固定数组的大小来用这个函数了。用模板加数组的引用可以解决这个问题，看如下代码：
 

  template <int sz>
 
 void test(char (&arr)[sz])
 
 {
 
     for (　int i = 0; i < sz; i++　)
 
           ......}char a[2] = { 0 }, b[15] = { 0 };test(a);　　//oktest(b);　　//ok......
 

       这样解决了数组长度可变的问题，但也引入了新的问题：
 

  （１）当有多个不同的test调用时，会产生多份test代码。而传统的函数调用只有一份代，也调用的次数无关。
 
 （２）由于这些代码都是在编译阶段生成的，它需要知道引用数组的大小。所以这样写的函数显然不能用指针变量作为函数的参数，因此不能用这个函数处理动态分配的内存区域，这样的区域的大小是在运行时确定的。

在Bjarne Stroustrup(C++创始人，他的主页)所写的《The C++ Programming Language, special edition》书中的第5章5.9节的第1题练习题中，要求写一个声明语句并进行初始化，“a reference to an array of 10 integers”，实现如下：
 
 
//an array of 10 integers
int arry[10] = {0};

//a reference to an array of 10 integers
int (&rcp)[10] = arry;
 
 
因为&的优先级低于[]，所以要加上圆括号，不加圆括号，则表示数组的每个元素的类型为int &：
 
 
int &rcp[10];
 
 
如果将数组名理解为常量指针，则也可以这样写：
 
 
int *const &rcp1 = arry;//reference to a constant pointer to integer
 
 
不过，这里的变量rcp1变成了对一个常量指针的引用。
 
 
利用数组引用及模板，可以实现一个获取任意类型数组大小的函数：
 
 
template<class T, size_t N>
size_t getArraySize(T (&)[N]) {
  return N;
}
 
 
函数的参数必须为数组名或数组引用：
 
 
int main() {
  int iarry[10];
  int (&rarry)[10] = iarry;
  int *const parry = iarry;
  cout << getArraySize(iarry) << endl; //output: 10
  cout << getArraySize(rarry) << endl; //output: 10
  cout << getArraySize(parry) << endl; //error

  return 0;
}
 
 

 References: 
 
http://devmaster.net/forums/topic/4834-reference-to-an-array-of-integers/
 

 
 

  所谓数组引用，即指向数组的引用；
  
 如    int   a[10] ;    
  
     　int   (&b)[10] = a ;
  
 如果写成　int   a[10] ;
  
               　 int* &b = a ;
  
 将会报错： cannot convert from 'int [10]' to 'int *&'。
  
 　　或许你会说在数组名不就是指向这个数组的一个指针吗？题中a是int*类型的，b是指向int*的引用，按理应该是正确的啊，为什么会报错呢？这是因为编译器对指向数组的引用检查更加严格，需要检查数组的维数，在这里a被理解成指向10个int数组的指针int [10]，对于引用也需要相应的引用类型int (&)[10]，即指向10个int数组的指针的引用。
 
 
 

  c和c++中有一个“数组降价”问题。
 
 
 

  #include <iostream>
 
 
 

  void test( char arr[100] )
  
 {
  
      std::cout << sizeof(arr) << std::endl ; // 输出 4
  
 }
 
 
 

  int main()
  
 {
  
     char arr[100] = { 0 };
  
     std::cout << sizeof(arr) << std::endl; // 输出 100　
  
     test( arr );
 
 
 

  
     return 0 ;
  
 }
 
 
 

  这段代码的输出是100
  
                             4
 
 
 

  
       对于同样的arr,一个输出100，另一个输出4。是因为void test( char arr[100] )中的arr被降价了。
 
 
 

  void test( char arr[100] ) 中的arr被降阶处理了，
  
        void test( char arr[100] ) 等同于void test( char arr[] )， 也等同于
  
 　　void test( char* const arr ) 如果你原意，它甚至等同于
  
 　　void test( char arr[10] )
  
 　　编译器对数组的维数不作检查。
 
 
 

  也就是说
  
 void test( char arr[100] )
  
 {
  
      std::cout << sizeof(arr) << std::endl;
  
 }
 
 
 

  
 被降成
  
 void test( char* const arr )
  
 {       std::cout << sizeof(arr) << std::endl; // 既然是char*，当然输出4
  
 }     这样，即然不检查数组的大小，对于需要保证数组大小的程序就会带来问题。如何解决这个问题呢？可以用c++中的对数组的引用。
  
 看下面这段代码：
 
 
 

  ......
 
 
 

  void test( const char (&arr)[100] )
  
 {
  
      std::cout << sizeof(arr) << std::endl ; // 输出 100
  
 }
 
 
 

  ......
  
     char arr[100] = { 0 };
  
     std::cout << sizeof(arr) << std::endl; // 输出 100　
  
     test( arr );
  
 ......
 
 
 

  这样test就能接受100个char的数组，且只能接受大小为100的char数组
 
 
 

  如果
  
 　　char　arr[20] = {0};
  
        test( arr ) ;
  
 就会报错
 
 
 

  　　在C++ 中，对数组的引用可以直接传递数组名，因为数组的大小的信息已在形参里提供了。但是这样一来我们只能固定数组的大小来用这个函数了。用模板加数组的引用可以解决这个问题，看如下代码：
 
 
 

  template <int sz>
  
 void test(char (&arr)[sz])
  
 {
  
     for (　int i = 0; i < sz; i++　)
  
           ......
  
 }
  
 char a[2] = { 0 }, 
  
 char b[15] = { 0 };
  
 test(a);　　//ok
  
 test(b);　　//ok......
 
 
 

       这样解决了数组长度可变的问题，但也引入了新的问题：
 
 
 

  （１）当有多个不同的test调用时，会产生多份test代码。而传统的函数调用只有一份代，也调用的次数无关。
  
 （２）由于这些代码都是在编译阶段生成的，它需要知道引用数组的大小。所以这样写的函数显然不能用指针变量作为函数的参数，因此不能用这个函数处理动态分配的内存区域，这样的区域的大小是在运行时确定的。
 
 

 所谓数组引用，即指向数组的引用；
 
如:               int   a[10] ;    
 
                    int   (&b)[10] = a ;
 
如果写成:     int   a[10] ;
 
                    int* &b = a ;
 
将会报错： cannot convert from 'int [10]' to 'int *&'。
 

 
或许你会说在数组名不就是指向这个数组的一个指针吗？题中a是int*类型的，b是指向int*的引用，按理应该是正确的啊，为什么会报错呢？这是因为编译器对指向数组的引用检查更加严格，需要检查数组的维数，在这里a被理解成指向10个int数组的指针int [10]，对于引用也需要相应的引用类型int (&)[10]，即指向10个int数组的指针的引用。


 c和c++中有一个“数组降价”问题。


 #include <iostream>


 void test( char arr[100] )
 
{
 
     std::cout << sizeof(arr) << std::endl ; // 输出 4
 
}


 int main()
 
{
 
    char arr[100] = { 0 };
 
    std::cout << sizeof(arr) << std::endl; // 输出 100　
 
    test( arr );
 
    return 0 ;
 
}


 这段代码的输出是:  100
 
                                  4


 
对于同样的arr,一个输出100，另一个输出4。是因为void test( char arr[100] )中的arr被降价了。


 void test( char arr[100] ) 中的arr被降阶处理了，
 
void test( char arr[100] ) 等同于void test( char arr[] )， 也等同于
 
void test( char* const arr ) 如果你原意，它甚至等同于
 
void test( char arr[10] )
 
编译器对数组的维数不作检查。也就是说
 
void test( char arr[100] )
 
{
 
     std::cout << sizeof(arr) << std::endl;
 
}


 
被降成
 
void test( char* const arr )
 
{     
 
  std::cout << sizeof(arr) << std::endl; // 既然是char*，当然输出4
 
}     
 
这样，即然不检查数组的大小，对于需要保证数组大小的程序就会带来问题。如何解决这个问题呢？可以用c++中的对数组的引用。
 
看下面这段代码：


 



 void test( const char (&arr)[100] )
 
{
 
     std::cout << sizeof(arr) << std::endl ; // 输出 100
 
}


 char arr[100] = { 0 };
 
std::cout << sizeof(arr) << std::endl; // 输出 100　
 
test( arr );
 

 



 这样test就能接受100个char的数组，且只能接受大小为100的char数组


 如果:
 
char　arr[20] = {0};
 
test( arr ) ;
 
就会报错


 在C++ 中，对数组的引用可以直接传递数组名，因为数组的大小的信息已在形参里提供了。但是这样一来我们只能固定数组的大小来用这个函数了。用模板加数组的引用可以解决这个问题，看如下代码：


 template <int sz>
 
void test(char (&arr)[sz])
 
{
 
    for (　int i = 0; i < sz; i++　)
 
          ......
 
}
 
char a[2] = { 0 }, b[15] = { 0 };
 
test(a);　　//ok
 
test(b);　　//ok


 
这样解决了数组长度可变的问题，但也引入了新的问题：


 （１）当有多个不同的test调用时，会产生多份test代码。而传统的函数调用只有一份代，也调用的次数无关。
 
（２）由于这些代码都是在编译阶段生成的，它需要知道引用数组的大小。所以这样写的函数显然不能用指针变量作为函数的参数，因此不能用这个函数处理动态分配的内存区域，这样的区域的大小是在运行时确定的。