所谓数组引用，即指向数组的引用；
如    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 
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 
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代码。而传统的函数调用只有一份代，也调用的次数无关。
（２）由于这些代码都是在编译阶段生成的，它需要知道引用数组的大小。所以这样写的函数显然不能用指针变量作为函数的参数，因此不能用这个函数处理动态分配的内存区域，这样的区域的大小是在运行时确定的。

          
c语言中在某个文件中定义的全局变量可以在不同的文件中引用，对数组和指针这两种全局变量在使用时必须要注意，外部引用格式不正确时会出现编译或运行错误。下面通过不同的例子来说明数组和指针类型全局变量的引用。
一、全局变量为数组
 example1:
test1.c  
int a[10] = {1,2,3,4,5};  
 
test2.c  
#include <stdio.h>  
#include <stdlib.h>  
extern int a;  
int main()  
{  
    printf("%d\n", a[2]);  
    return 0;  
} 
 编译时会出现下面错误，说明在test2中的extern引用的a实际上是一个变量，而不是一个数组，在第10行会出现编译错误。
error: subscripted value is neither array nor pointer  
example2:
test1.c:  
int a[10] = {1,2,3,4,5};  
 
test2.c:  
#include <stdio.h>  
#include <stdlib.h>  
extern int a[];  
int main()  
{  
    printf("%d\n", a[2]);  
    return 0;  
} 
此例编译和运行都没有任何问题，运行结果为3。说明extern引用的a就是在test1.c中定义的数组。
example3:
test1.c:  
int a[10] = {1,2,3,4,5};  
 
test2.c:  
#include <stdio.h>  
#include <stdlib.h>  
extern int *a;  
int main()  
{  
    printf("%d\n", a[2]);  
    return 0;  
} 
此例在编译时没有任何问题，但是运行时会出现野指针访问错误，因为此处a被认为是外部定义的一个指针变量，但是这个指针变量并没有指向某个对象，所以在运行过程中会出现随机访问内存的情况。
				
转载于:https://blog.51cto.com/coldcloudy/970380

    
只能对字符数组的元素赋值,而不能用赋值语句对整个数组赋值.
char c[5];
c={′C′,′h′,′i′,′n′,′a′}; //错误,不能对整个数组一次赋值
c[0]=′C′; c[1]=′h′;c[2]=′i′;c[3]=′n′;c[4]=′a′; //对数组元素赋值,正确
 
如果已定义了a和b是具有相同类型和长度的数组,且b数组已被初始化,请分析:
a=b; //错误,不能对整个数组整体赋值
a[0]=b[0]; //正确,引用数组元素
 
字符串和字符串结束标志
常量来初始化字符数组。例如
char str[]={′′I am happy′′}; 也可以省略花括号,直接写成
char str[]=′′I am happy′′;
上面的初始化与下面的初始化等价: char str[]={′I′,′ ′,′a′,′m′,′ ′,′h′,′a′,′p′,′p′,′y′,′\0′};
 
需要说明的是:字符数组并不要求它的最后一个字 符为′\0′,甚至可以不包含′\0′。如以下这样写完全是合法的:
char str[5]={′C′,′h′,′i′,′n′,′a′};
是否需要加′\0′,完全根据需要决定。但是由于 C++编译系统对字符串常量自动加一个′\0′。
人们为了使处理方法一致,便于测定字符串的实际长度,以及在程序中作相应的处理,在字符数组中有效字符的后面也人为地加上一个′\0′。
如 char str [6]={′C′,′h′,′i′,′n′,′a′,′\0′};


转载于:https://www.cnblogs.com/galoishelley/p/3853074.html

1.单选题
1.若有说明：int a[10]；，则对数组元素的正确引用是（）。
正确答案: D   你的答案: 空 (错误)
a[10]；
a[3.5]
a(5)
a[10-10]
【解释】因为定义的数组包含10个元素，对数组元素引用的下标是从0~9。显然a[10]
超出了数组的范围，A是错误的引用。因数组下标的数据类型必须是整型，所以B是错误
的。数组引用应使用中括号，小括号是非法的，所以C也是错误的。故正确答案是D，即

引用a[0]。
2.有以下C语言程序
#include   <stdio.h>

int fun(int  x[], int  k)

{  if(k==0) return (x[0]);

return  x[0]+fun(x+1, k-1);

}

int main()

{  int  x[ ]={1,2,3,4,5};

printf("%d\n", fun(x,3));

}

程序运行后的输出结果是  10

解释：

fun(x,3)

=x[0]+fun(x+1,2)

=x[0]+x[1]+fun(x+2,1)

=x[0]+x[1]+x[2]+fun(x+3,0)

=x[0]+x[1]+x[2]+x[3]

=10

子函数新定义了一个数组，分别把数组的下一位作为这个新的数组的头地址。
3.
int FindSubString( char* pch )
{
    int   count  = 0;
    char  * p1   = pch;
    while ( *p1 != '\0' )
    {   
        if ( *p1 == p1[1] - 1 )
        {
            p1++;
            count++;
        }else  {
            break;
        }
    }
    int count2 = count;
    while ( *p1 != '\0' )
    {
        if ( *p1 == p1[1] + 1 )
        {
            p1++;
            count2--;
        }else  {
            break;
        }
    }
    if ( count2 == 0 )
        return(count);
    return(0);
}
void ModifyString( char* pText )
{
    char  * p1   = pText;
    char  * p2   = p1;
    while ( *p1 != '\0' )
    {
        int count = FindSubString( p1 );
        if ( count > 0 )
        {
            *p2++ = *p1;
            sprintf( p2, "%i", count );
            while ( *p2 != '\0' )
            {
                p2++;
            }
            p1 += count + count + 1;
        }else  {
            *p2++ = *p1++;
        }
    }
}
void main( void )
{
    char text[32] = "XYBCDCBABABA";
    ModifyString( text );
    printf( text );
} 

输出为：XYBCDCBA1BAA

解释： FindSubString() 函数就是要找到一个先递增再递减且递增和递减的数量相等的回文序列，例如： ABCDCBA ，先是   后一项 = 前一项 ASCII 码 +1 ， 后是   后一项 = 前一项 ASCII 码 -1 ，才能返回回文子串的长度，否则返回 0 。
ModifyString() 函数不断寻找上述类型的子串，如果不满足条件，就
*p2++ = *p1++;
当遇到 ABABA 中前一个 ABA 的时候，满足回文子串要求，此时 p1 指向 A BABA ， p2 指向 ABABA ； sprintf 重定向修改 ABABA ， B 变为 1 ，且跟随一个 ‘\0’ （该函数自动产生的） , 此时，字符串变为 A1‘\0’BA 。
经过    while ( *p2 != ‘\0’ ) 循环之后， p2 指向 A1‘\0’BA ， p1 += count + count + 1 之后， p1 指向 A1‘\0’BA 。此时字符串已经被改动，之前的 ABABA 已经不存在，变为 A1‘\0’BA 。
再次进入 while ( *p1 != ‘\0’ ) 循环之后，只能执行 else 部分的命令， p1 指向 p2 指向的元素的后一个，不断将 p1 指向的元素传给 p2 所指向的位置，将原数据覆盖。所以， A1‘\0’BA ，依次变为 A1BBA 、 A1BAA 。即最终结果为 XYBCDCBA1BAA 。
4. 假设数原型和变量说明如下：
void f4(int **p);

int a[4]={1,2,3,4};

int b[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

int *q[3]={b[0],b[1],b[2]};
下面哪个调用是合法的？

正确答案: C   你的答案: 空 (错误)
f4(a)；
f4(b)；
f4(q)；
f4(&a);
解释： 根据题干void f4(int **p); f4的参数为指向指针的指针，即p为一个指针的地址。指向指针的指针是一种多级间接寻址的形式。

选项A f4(a)，参数为一维数组名，即首元素的地址&a[0]。

选项B f4(b)，参数为二维数组名，及首元素的地址。

选项C f4(q)，参数q为一个指针数组，元素为int类型的指针，数组名为首元素b[0]的地址。

选项D f4(&a)，参数转化为&a[0]。等同于选项A
5.
class Test

{

public:

____ int a;

____ int b;

public:

Test::Test(int _a , int _b) : a( _a )

{

b = _b;

}

};

int Test::b;

int main(void)

{

Test t1(0 , 0) , t2(1 , 1);

t1.b = 10;

t2.b = 20;

printf("%u %u %u %u",t1.a , t1.b , t2.a , t2.b);

return 0;

}

正确答案: B C   你的答案: B (错误)
static/const
const/static
–/static
conststatic/static
None of above

解释：对于成员变量a，若它为const类型，那么必须要使用Test::Test(int _a , int _b) : a( _a )这种初始化形式，若它为普通成员变量，也可以采取Test::Test(int _a , int _b) : a( _a )这种形式，所以a可以为const或者普通类型，由于b没有采取Test::Test(int _a , int _b) : b( _b )这种形式，所以b一定不是const类型，有main()中的t1.b和t2.b的输出都是20可以知道，b是静态变量。
5.
设有语句 int a=5；

则执行表达式a-=a+=a*a后，a的值是?

正确答案: C   你的答案: 空 (错误)

-5
25
0
-20
解释：

C语言中对赋值运算的运算顺序是自右向左。

①计算aa之后，a的值依然为5，表达式aa的值为25；

②执行+=运算，a+=25， a=5+25=30;此时a的值变为30；

③a-=30，a=30-30=0。最后a的值为0。
6.
没用参数的两个函数是不能重载的.说法是否正确？

正确答案: B   你的答案: A (错误)
正确
错误
解释：

1、C++不允许仅根据函数的返回类型重载函数名称；

2、可以编写两个名称相同，参数也相同的函数，其中一个是const，另一个不是。
7.
如果定义 ： float a[10], x;
则以下叙述中正确的是（）

正确答案: A   你的答案: D (错误)
语句 a = &x; 是非法的
表达式 a+1 是非法的
三个表达式 a[1]、*(a+1)、&a[1]表示的意思完全不同
表达式*&a[1]是非法的，应该写成 *(&(a[1]))
解释： 数组名是数组的首地址，就是数组中第一个元素的地址，是常量。常量是不能出现在赋值号=左边作为左值的。
8.
以下代码的运行结果是（）

代码 Ⅰ : unsigned int uiA；uiA = (0 × AB & 0 × CD) ^ (0 × EF │ 0 × AB);

代码 Ⅱ ： unsigned int uiB；uiB = 0 × AA │ (0 × BB << 8) │ (0 × CC<<16) │ (0 × DD<<24);

正确答案: C   你的答案: 空 (错误)
代码Ⅰ，uiA=0×77

代码Ⅱ，ui8 =0×DDCCBBAACD

代码Ⅰ，uiA=0×66

代码Ⅱ，ui8 =0×AABBCCDD
解释： uiA=(0x89)^(0xEF)=0x66

uiB=(0xAA)|(0xBB00)|(0xCC0000)|(0xDD000000)=0xDDCCBBAA ，^是异或符号。
9.
对于#include   <filename.h> 和 #include “filename.h”，以下说法错误的是（ ）。

正确答案: B   你的答案: 空 (错误)
#include <filename.h>只搜索标准库路径
#include “filename.h”只搜索用户工作路径
#include <filename.h>搜索范围比#include “filename.h”小
两者可能等价
解释：A：正确,B 错的，

首先 #include<> 和 #include"" 只是最先搜索的路经不一样。

#include<>  :表示只从从标准库文件目录下搜索，对于标准库文件搜索效率快。

#include""    :表示首先从用户工作目录下开始搜索，对于自定义文件搜索比较快，然后搜索整个磁盘。
10.
C++是不是类型安全的？

正确答案: B   你的答案: A (错误)
是
不是

解释：C++中我们可以将0作为false，非零作为true。一个函数即使是bool类型的，但是我们还是可以返回int类型的，并且自动将0转换成false，非零转换成true。 java中int类型不能在自动转变成bool类型了，这就是类型安全的意思。类型之间可以进行强制转换，表示类型不安全。
11.
下列运算符，在C++语言中不能重载的是（）

正确答案: B C   你的答案: B C D (错误)



.*
::
operator  delete

解释：可以这样记忆，带.的都不能被重载 。除了 . ， .* ， :: ， ? : ， sizeof ， typeid 这几个运算符不能被重载，其他运算符都能被重载。delete不能够重载，operator delete可以重载。

.表示成员选择

.*表示指向成员操作的指针

？:表示条件操作

::作用域符