Day10：C语言学习作业

老薛爱吃大西瓜

已于 2024-09-11 21:25:46 修改

阅读量672

点赞数 30

文章标签：算法数据结构 c语言学习

于 2024-09-11 21:24:39 首次发布

本文链接：https://blog.csdn.net/qq_57461392/article/details/142147127

版权

以下程序的正确运行结果是( )

int f(int a);

int main(void)

{

    int a = 2,i;

for(i = 0; i < 3; i++)

printf("%4d", f(a));

}

int f(int a)

{

    int b = 0;

    static int c = 3;

    b++;

c++;

    return (a+b+c);

}

A. 777 B. 7 10 13 C. 7 9 11 D. 7 8 9

答案：D

分析：主函数中a的值不变，在for循环内，没有传参地址，所以a的值不变，一直是2，在函数 f() 中c是静态的，可以改变值，循环了3次，每次都 +1 所以 a+b+c 为7 8 9

在一个被调用函数中，关于return语句使用的描述，( )是错误的

A. 被调用函数中可以不用return语句

B. 被调用函数中可以使用多个return语句

C. 被调用函数中，如果有返回值，就一定要有return语句

D. 被调用函数中，一个return语句可以返回多个值给调用函数

答案：D

分析： A：void函数不用返回值，B：函数可以有多个return，但只能有一个return能使用，所以D是错的

以下程序的运行结果为( )

#include <stdio.h>

#include <string.h>

int SubCount(char *dest, int count)

{

    strcpy(dest, "555");

    count++;

    return 0;

}

int main()

{

    int count = 3;

    char caBuf[8];

    SubCount(caBuf, count);

    printf("%d\n", count);

    return 0;

}

A. 8 B. 4 C. 3 D. 5

答案：C

分析：主函数中传递的参数不是地址，所以在函数中改变值，并不影响main函数中的值

请问运行Test函数会有什么样的结果？

char *GetMemory(void)

{

    char p[] = "hello world";

    return p;

}

void Test(void)

{

    char *str = NULL;

    str = GetMemory();

    printf(str);

}

答案：NULL

分析：如果函数里面是对指针操作，则返回指针可以将给与的值返回，但函数里面是对数组，也就是对新开辟的空间操作，所以在函数结束后，空间将会清空

分析以下程序，写出运行结果并写出过程

#include <stdio.h>

#include <stdlib.h>

void getalloc(char *p)

{

    p = (char *)malloc(100);

    strcpy(p, "hello world");

}

int main()

{

    char *str = NULL;

    getalloc(str);

    printf("%s\n",str);

    free(str);

    return 0;

}

答案：NULL

分析：首先函数没有导入 strcpy() 函数的头文件 string.h，第二，在函数中malloc会分配新的临时空间，当函数结束时，空间就会被自动释放，则str还是指向空

下列程序的输出结果是________

fun(int a, int b, int c)

{

    c = a*b;

}

void main()

{

    int c = 10;

    fun(2,3,++c);

    printf("%d\n", c);

}

答案：11

分析：传参C不是传的地址，所以不会再函数中改变C的值，++c结果时11

找错题，说明那里错了

void test1()

{

    char string[10];

    char *str1 = "0123456789";

    strcpy( string, str1 );

}

答案：段错误

分析： string只有十个空间，而str1有十个值加上\0一共十一个空间

下面的代码片段会输出__________

void test(void)

{

    char *p = NULL;

    strcpy(p, "hello");

    printf("%s", p);

}

答案：段错误

分析：p指针没有指向空间，所以对其赋值会符不上，结果时段错误

sizeof(str); 的值是多少？

void Func(char str[100])

{

sizeof(str);

}

答案：8

分析：因为函数传参数组是传入指针，而指针占8字节

递归函数最终会结束，那么这个函数一定( )

A. 使用了局部变量

B. 有一个分支不调用自身

C. 使用了全局变量或者使用了一个或多个参数

答案：B

分析：在递归函数中，最内层中，是不需要调用自身，只需要返回值，

程序如下，程序执行后的输出结果是：

int f(int x, int y)

{

    return (y-x)*x;

}

void main()

{

    int a = 3,b=4,c=5,d;

    d=f(f(3,4),f(3,5));

    printf("%d\n", d);

}

答案：9

分析：f(3,4)=3，f(3,5)=6，f(3,6)=9

请判断下面程序输出的值是多少？

int func(int a)

{

    static int b = 0;

    b+=a;

    return b;

}

int main(void)

{

    printf("%d %d\n", func(1)+func(3), func(5));

}

答案：5 9

分析：fun(1)=1，fun(3)=4，fun(5)=9

这段程序的输出是(________)

void f1(int *, int);

void f2(int *, int);

void(*p[2]) (int *, int);

main()

{

    int a;

    int b;

    p[0] = f1;

    p[1] = f2;

    a=3;

    b=5;

    p[0](&a, b);

    printf("%d\t %d\t", a, b);

    p[1](&a, b);

    printf("%d\t %d\t", a, b);

}

void f1(int * p, int q)

{

    int tmp;

    tmp = *p;

    *p = q;

    q = tmp;

}

void f2(int *p, int q)

{

    int tmp;

    tmp = *p;

    *p = q;

    q = tmp;

}

A. 5 5 5 5 B. 3 5 3 5 C. 5 3 5 3 D. 3 3 3 3

答案：A

分析：p是函数指针数组，p[0] 是f1，p[1] 是f2，两个函数都是交换传入参数的值，但p都是指针，也就是函数可以改变p的值，但不能改变b的值，所以调用 p[0] 的时候，a 变成了5，b 没有改变，也就是a和b都是5了，调用 p[1] 时，又交换了一边，但两个值相同，所以结果还是5 5

有以下程序段, x=7执行后的值为 ( ) (杭州快越科技)

int fun(int x) {

int p;

if(x==0||x==1)

return(3);

p=x-fun(x-2);

return p;

}

A. 0 B. 2 C. 5 D. 6

答案：B

分析：这是递归调用，步长为2，也就是x=7，5，3，1，在x=1时，返回值为3，最终计算方法为：7-5-3-3=2

有以下函数，该函数的返回值是：( ) (山东信通电子)

char *fun(char *p)

{

return p;

}

A. 无确切的值 B. 形参 p 中存放的地址值

C. 一个临时存储单元的地址 D. 形参 p 自身的地址值

答案：D

分析：返回的时传入的地址

编写strcpy函数

已知strcpy 函数的原型是

char *strcpy(char *strDest,const char *strSrc);其中 strDest 是目的字符串，strSrc 是源字符串。

(1)、不调用 C 的字符串库函数，请编写函数 strcpy。

(2)、strcpy 能把 strSr 的内容复制到 strDest，为什么还有 char"类型的返回值?

(3)、strcpy 和 memcpy 的区别。

答案：写多了，多写了个strcat，懒得删了

2）因为对函数传参后，对其操作的是形参，如果不对其返回，会使操作结果释放掉

3）strcpy是将strSrc字符串复制给strDest，将strDest的数据清空，memcpy是将n个字符给复制过去

#include <stdio.h>
//创建strcat类函数
char *my_strcat(char *a, char *b);
//创建strcpy类函数
char *my_strcpy(char *a, char *b);

int main(){
    //创建目标数组
    char a[100] = "what can";
    //创建原数组
    char b[100] = "i say";
    //调用接入函数
    my_strcat(a,b);
    printf("%s\n",a);
    my_strcpy(a,b);
    printf("%s\n",a);
    return 0;
}
//a：目标数组，b：原数组
char *my_strcpy(char *a, char *b) {
    int i;
    //遍历数组，将b的值赋给a
    for (i = 0; b[i] != '\0'; ++i) {
        a[i] = b[i];
    }
    //打上断点
    a[i] = '\0';
    return a;
}

//a是指针参数，记录目标字符串，b是需要接入的函数
char *my_strcat(char *a, char *b) {
    //遍历数组a，找到'\0'位置
    int i = 0;
    while (a[i] != '\0'){
        i++;
        a++;
    }
    //给a的结尾加入空格，使a指针后移有一位
    a[i] = ' ';
    i++;
    //遍历数组b，循环插入a
    int j = 0;
    while (b[j] != '\0'){
        a[i] = b[j];
        j++;
        i++;
    }
    //给结尾打上\0
    a[i] = '\0';
    return a;
}

请实现一个函数，输入一个整数，输出该数二进制表示中的1的个数。例如：把9表示成二进制是1001，有2位是1。因此如果输入9，该函数输出2

#include <stdio.h>

int main(){
    //创建数字容器，通过键盘键入
    int num;
    scanf("%d",&num);
    //创建1的计数器
    int count = 0;
    //重复计算1的结果
    for (int i = 0; num != 0 ; ++i) {
        if(num % 2 == 1)
            count++;
        num /= 2;
    }
    //输出结果
    printf("%d\n",count);

    return 0;
}

请用编写递归算法计算fibinacci数列第1000位的值。斐波拉契数列为1,1,2,3,5,8,13,21,……

答案：跟最后一题一样，跑不出来，数据结果远超数据类型的容量，需要用数组

#include <stdio.h>

int fun(int n);

int main(){
    //创建数字容器，通过键盘键入
    int n;
    scanf("%d",&n);
    //输出结果
    printf("%d\n", fun(n));
    return 0;
}
//递归计算
int fun(int n) {
    if(n == 1 || n == 2){
        return 1;
    } else
        return fun(n - 1) + fun(n - 2);
}

用 C 语言写一个递归算法求 N！

答案：这个可以计算阶乘，但是只能计算14以内的阶乘，因为超出14以后无法被普通的数据类型接收，需要通过数组接受，比较复杂这里就不写了，因为我要回家

#include <stdio.h>

int fun(int n);

int main(){
    //创建数字容器，通过键盘键入
    int n;
    scanf("%d",&n);
    //输出结果
    printf("%d\n", fun(n));
    return 0;
}
//递归计算
int fun(int n) {
    //当n等于1时到达栈顶，返回1
    if(n == 1){
        return 1;
    } else
    //计算阶乘
        return n * fun(n - 1);
}