已定义以下函数      Int fun（int *p）      {return *p；}  则fun函数返回值是（）A、不确定的值B、一个整数C、形参P中存放的值D、形参P的地址值

有以下函数：

fun（char *p）

{return p;}

该函数的返回值是

A．无确切值

B．形参p中存放的地址值

C．一个临时存储单元的地址

D．形参p自身的地址值

已定义下列函数：

int fun(int*p)

{return*p;)

fun函数返回值是( )。

A．不确定的值

B．一个整数

C．形参p中存放的值

D．形参p的地址值

A.voidfun(inta[]);

B.voidfun(int*&a);

C.voidfun(int&a[]);

D.voidfun(int&*a);

以下程序段是函数返回a所指数组中最小的值所在的下标值，请在下划线处填空。

fun(int *a,int n)

{

int i,j=0，p；

p=j；

for(i=j；i＜n；i++)

if(a[i]＜a[p]) 【 】；

return(p)；

}

有以下函数 char *fun(char*p) { return p； } 该函数的返回值是_____。

A．无确切的值

B．形参p中存放的地址值

C．一个临时存储单元的地址

D．形参p自身的地址值

以下程序段中，能够通过调用函数fun()，使main()函数中的指针变量p指向一个合法的整型单元的是( )。

A．main() {int*p; fun(p); … } int fun(int*p) {int s; p=&s; }

B．main {int*p fun(&p); … } iht fun(int**p) {int s; *p=&s;}

C．main() {int*p; fun(&p); } int fun(int**p) {*p=(int*)malloc(2);}

D．main() {int*p; fun(p); } int fun(int*p) {p=(int*)malloc(sizeo(int));}

以下函数fun的功能是返回str所指字符串中以形参c中字符开头的后续字符串的首地址，例如，str所指字符串为Hello!，c中的字符为e，则函数返回字符串ello!的首地址。若str所指字符串为空或不包含c中的字符，则函数返回NULL，请填空。char *fun(char *str,char c){ int n=0; char *p=str; if(p!=NULL) while(p[n]!=c&&p[n]!=’\0’) n++; if(p[n]==’\0’) return NULL; return();}

已定义以下函数：

fun函数的返回值是（ ）。

A.一个整数

B.不确定的值

C.形参P中存放的值

D.形参P的地址值

有函数char fun(char *p){ return p; }该函数的返回值是( )。

A．编译出错

B．形参p中存放的地址值

C．一个临时存储单元的地址

D．形参p自身的地址值

若有函数 char*func(char *p) { … return p; } 则该函数的返回值是 ______。

A．无确切的值

B．形参p中存放的地址

C．一个临时存储单元的地址

D．形参p自身的地址

已定义以下函数： int fun(int*p) {return*P；) fun函数返回值是( )。

A．不确定的值

B．一个整数

C．形参P中存放的值

D．形参P的地址值

以下程序中，能够通过调用函数fun，使main函数中的指针变量p指向一个合法的整型单元的是

A．main( ) { int *p; fun(p); ┆ } int fun(int *p) { int s; p=&s;}

B．main( ) { int *p; fun(&p); ┆ } int fun(int **p) { int s; *p=&s;}

C．#include＜stdlib.h＞ main( ) { int *p; fun(&p); ┆ } int fun(int **p) { *p=(int*)malloc(2);}

D．#include＜stdlib.h＞ main( ) { int *p; fun(p); ┆ } int fun(int *p) { p=(int*)malloc(sizeof(int));}

阅读以下函数说明和C语言函数，将应填入(n)的字句写在答题纸的对应栏内。

[说明1]

函数int fun1(int m, int n)的功能是：计算并返回正整数m和n的最大公约数。

[函数1]

int fun1(int m, int n)

{

while ((1)) {

if (m＞n) m=m-n;

else n=n-m;

}

(2);

}

[说明2]

函数long fun2(char*str)的功能是：自左至右顺序取出非空字符串str中的数字字符形成一个十进制整数(最多8位)。

例如，若字符串str的值为“f3g8d5.ji2e3p12fkp”，则函数返回值为3852312。

[函数2]

long fun2(char *str)

{

int i=0;

long k=0;

char *p=str;

while (*p!='＼0' &&(3)) {

if (*p＞='0' && *p＜='9') {

k=(4)+ *p - '0';

++i;

}

(5);

}

return k;

}

阅读下列说明和C代码，将应填入(n)处的字句写在对应栏内。

【说明】

本题给出四个函数，它们的功能分别是：

1．int push(PNODE*top，int e)是进栈函数，形参top是栈顶指针的指针，形参e是入栈元素。

2．int pop(PNODE*top，int*e)是出栈函数，形参top是栈顶指针的指针，形参e作为返回出栈元素使用。

3．int enQueue(PNODE*tail，int e)是入队函数，形参tail是队尾指针的指针，形参e是入队元素。

4．int deQueue(PNODE*tail，int*e)是出队函数，形参tail是队尾指针的指针，形参e作为返回出队元素使用。

以上四个函数中，返回值为。表示操作成功，返回值为-1表示操作失败。

栈是用链表实现的；队是用带有辅助结点(头结点)的单向循环链表实现的。两种链表的结点类型均为：

typedef struct node {

int value;

struct node * next;

} NODE, * PNODE;

【函数1】

int push(PNOOE * top,int e)

{

PNODE p = (PNODE) malloc (sizeof (NODE));

if (! p) return-1;

p-＞value=e;

(1);

*top=p;

return 0;

}

【函数2】

int pop (PNODE * top,int * e)

{

PNODE p = * top;

if(p == NULL) return-1;

* e = p-＞value;

(2);

free(p);

return 0;

}

【函数3】

int enQueue (PNODE * tail,int e)

{ PNODE p,t;

t= *tail;

p = (PNODE) malloc(sizeof(NODE));

if(!p) return-1;

p-＞value=e;

p-＞next=t-＞next;

(3);

* tail = p;

return 0;

}

【函数4】

int deQueue(PNODE * tail,int * e)

{ PNODE p,q;

if(( * tail)-＞next == * tail) return-1;

p= (* tail)-＞next;

q = p -＞next;

* e =q -＞value;

(4)=q-＞next;

if(,tail==q) (5);

free(q);

return 0;

}

已定义以下函数： int fun(int *p) { return *p;} 函数fun的返回值是( )。

A．不确定的值

B．一个整数

C．形参p中存放的值

D．形参p的地址值

若有如下调用函数： int sub(int *t) { return (t)； } 该函数的返回值是( )

A．形参t中存放实参变量的地址值

B．形参t自身的地址值

C．指针变量t所指的实参变量的值

D．随机的值

有以下函数： charfun（char*D） {returnP；} 该函数的返回值是（ ）。

A.无确切的值

B.形参p中存放的地址值

C.一个临时存储单元的地址

D.形参p自身的地址值

已定义以下函数 int fun(int *p) {return *p;} fun函数返回值是______。

A．不确定的值

B．—个整数

C．形参p中存放的值

D．形参p的地址值

以下程序中，能够通过调用函数fun，使main函数中的指针变量p指向一个合法的整型单元的是

A．main() { int *p; fun(p); … } int fun(int *p) { ints; p=&s;}

B．main() { int *p; fun(&p); … } int fun(int **p) { int s; *p=&s;)

C．#include main() { int *p; fun(&p); … } int fun(int **p) *p=(int*)malloc(2);}

D．#include main() { iht *p; fun(p); … } iht fun(iht *p) { p=(int*)malloc(sizeof(int)); }