C语言入门速成(二)

发布于 2023-02-14  343 次阅读

  • 快考试了,从0学起,刷一遍考试题库
  • 上一篇两万字了才一半,这是第二篇

函数使用

  1. 以下正确的函数定义形式是( )。

A)double fun(int x, int y)

B)double fun(int x; int y)

C)double fun(int x, int y);

D)double fun(int x, y);

  • a
  1. 程序运行时，先从键盘输入二个不相同的整数值，依次调用GetMax,GetMin,Getaverage函数获取二个数中的最大值，最小最，平均值，并保存到Result数组中。然后输出。注意：只允许在/\start\/和/\end\/之间添加代码。

img

#include <stdio.h>
#include <stdlib.h>

/******start******/

/******end******/

int main()
{
    int Number1 = 0,Number2 = 0;
    int Result[3], i = 0;       //Result数组用来存存储的最大值，最小值和平均值
    printf("output:\ninput two numbers:\n");    

    scanf("%d%d", &Number1, &Number2);

    if(Number1 == Number2)
    {
        printf("输入二个不同的数字：\n");
        return 0;
    }

    /*在start和end之间完成函数的调用和参数的传递以及返回值的存储*/
    /******start******/

    /******end******/

    printf("\n最大数 最小数 平均值\n");
    for (i = 0; i < 3; i++)
    {
        printf("%6d", Result[i]);
    }

    printf("\n");
    return 0;
}

//取最大值函数
int GetMax(int x, int y)
{
    return (x > y) ? x : y;
}

//取最小值函数
int GetMin(int x, int y)
{
    return (x > y) ? y : x;
}

//取平均值函数
int GetAverage(int x, int y)
{
    return (x + y) / 2;
}
#include <stdio.h>
#include <stdlib.h>

/******start******/

/******end******/

int main()
{
    int Number1 = 0,Number2 = 0;
    int Result[3], i = 0;       //Result数组用来存存储的最大值，最小值和平均值
    printf("output:\ninput two numbers:\n");    

    scanf("%d%d", &Number1, &Number2);

    if(Number1 == Number2)
    {
        printf("输入二个不同的数字：\n");
        return 0;
    }

    /*在start和end之间完成函数的调用和参数的传递以及返回值的存储*/
    /******start******/
Result[0]=GetMax(Number1,Number2);
Result[1]=GetMin(Number1,Number2);
Result[2]=GetAverage(Number1,Number2);
    /******end******/

    printf("\n最大数 最小数 平均值\n");
    for (i = 0; i < 3; i++)
    {
        printf("%6d", Result[i]);
    }

    printf("\n");
    return 0;
}

//取最大值函数
int GetMax(int x, int y)
{
    return (x > y) ? x : y;
}

//取最小值函数
int GetMin(int x, int y)
{
    return (x > y) ? y : x;
}

//取平均值函数
int GetAverage(int x, int y)
{
    return (x + y) / 2;
}

函数程序

  1. 完成以下代码中的函数声明和定义。该函数用于将字符串反序，如"abc"反序为"cba"。

注意：只允许在/\start\/和/\end\/之间添加代码。

img

#include <stdio.h>
#include <string.h>

/******start******/

/******end******/

int main()
{
    char str[200]={0};
    printf("input a string: ");
    gets(str);

    ReverseString(str);

    puts("output:");
    puts(str);

    return 0;
}

/******start******/

/******end******/
  • 函数占位声明的时候还是要加;的
  • 这种方法可以轻松交换数组的数据
for (i = 0; i < j; i++, j--)
    {
        ch = str[i];
        str[i] = str[j];
        str[j] = ch;
    }
#include <stdio.h>
#include <string.h>

/******start******/
void ReverseString(char str[]);
/******end******/

int main()
{
    char str[200]={0};
    printf("input a string: ");
    gets(str);

    ReverseString(str);

    puts("output:");
    puts(str);

    return 0;
}

/******start******/
void ReverseString(char str[])
{
    char a;
    for(int i=0,q=strlen(str)-1;i<=q;i++,q--)
    {
        a = str[i];
        str[i] = str[q];
        str[q] = a;
    }

}
/******end******/
  1. 根据要求编写程序D5201的指定部分：

程序D5201.C已编写部分代码，请根据程序中的要求完善程序——注意，只能在/\start\/和/\end\/之间添加代码，不能对程序中已有部分作任何修改或重新编写一个程序，否则作0分处理。 程序的功能是：输入三角形的三边长a、b、c(约定为整数)，求三角形面积area，并输出。如果输入的三边构不成三角形，应给出“data error”的信息提示。注：根据“海伦－秦九韶”公式，area＝√p(p-a)(p-b)(p-c)，其中p＝(a+b+c)/2。 程序的运行效果应类似地如图1和图2所示，图1中的3,4,5和图2中的3,4,8是从键盘输入的内容。

img

img

#include <math.h>
#include <stdio.h>

/* 本部分代码功能建议：函数原型声明 */
/******start******/

/******end******/

int main(void)
{   
    int aBian, bBian, cBian;
    double mJi;

    printf("\nplease input triange sides:");
    scanf("%d,%d,%d", &aBian, &bBian, &cBian);

    if (aBian<0 || bBian<0 || cBian<0
            || (aBian+bBian <= cBian) || (aBian+cBian <= bBian) || (bBian+cBian <= aBian))
    {
        printf("\nOutput:\ndata error\n");
    }
    else
    {
        mJi = fun(aBian, bBian, cBian);
        printf("\nOutput:\narea=%.2f\n", mJi);
    }

    return 0;
}

/******start******/

/******end******/
#include <math.h>
#include <stdio.h>

/* 本部分代码功能建议：函数原型声明 */
/******start******/

/******end******/

int main(void)
{   
    int aBian, bBian, cBian;
    double mJi;

    printf("\nplease input triange sides:");
    scanf("%d,%d,%d", &aBian, &bBian, &cBian);

    if (aBian<0 || bBian<0 || cBian<0
            || (aBian+bBian <= cBian) || (aBian+cBian <= bBian) || (bBian+cBian <= aBian))
    {
        printf("\nOutput:\ndata error\n");
    }
    else
    {
        mJi = fun(aBian, bBian, cBian);
        printf("\nOutput:\narea=%.2f\n", mJi);
    }

    return 0;
}

/******start******/
double fun(int a, int b, int c);
double fun(int a, int b, int c)
{
    double p;
    p = (a+b+c)/2.0;
    return sqrt(p*(p-a)*(p-b)*(p-c));
}
/******end******/
  1. 从键盘上读入一行字符(约定：字符数≤127字节)，判断其中的注释是否合法，不合法则报错，合法时则删除注释后再输出。合法注释是指“/”标记注释开始、“/”标记注释结束，通常表现为/ ……/。 注意事项： (1)只考虑行内最多只包含一个注释的情况。 (2)不合法的注释情况有很多种，例如 ……/缺注释开始标记、/ ……/缺注释开始标记、/ ……缺注释结束标记、/ …… /缺结束标记。 (3)编程可用素材：printf("input a string:")...、printf("Output:\nThe result is :")...、printf("Output:\ncomment is error\n")...。 　　程序的运行效果应类似地如图1、图2、图3和图4所示，图1中的int main(void){char ch;/ding yi/ int i}、图2中的int main(void){char ch;ding yi/ int i}、图3中的int main(void){char ch;/ding yi* / int i}和图4中的int main(void){char ch; int i}是从键盘输入的内容。

程序运行效果示例：未解决

img

img

img

img

#include <stdio.h>
#include <string.h>

/******start******/
int main()
{
    int a=0,start,end;
    char ch[100];
    printf("input a string:");
    gets(ch);
    for(int i=0;i<=strlen(ch)-1;i++)
    {
        if(ch[i]=='/'&&ch[i+1]=='*')
        {
            a++;
            start=i;
        }
        if(ch[i]=='*'&&ch[i+1]=='/')
        {
            a++;
            end=i+1;
        }

    }
    printf("Output:\nThe result is :");
    if(a==0)puts(ch);
    if(a==1)printf("comment is error");
    if(a==2)
    {
        for(int i=0;i<=strlen(ch)-1;i++)
            {
                if(i<start||i>end)printf("%c",ch[i]);
            }
    }
    return 0;
}
  1. 根据要求编写程序的指定部分： 程序已编写部分代码，请根据程序中的要求完善程序——注意，只能在/\**start***/和/***end****/之间填加代码，不能对程序中已有其它部分作任何修改或重新编写一个程序，否则作**0分处理。 　　程序的功能是：先从键盘读入的8个学生的6门课成绩存放在二维数组student中(每一行存储一个学生的数据，第0列为学号，第1～6列依次为6门课的成绩)，再从键盘读入一个学号，在student查找该学生是否存在，若存在，则输出其平均成绩，若不存在，则显示“not Find!”。 　　程序的运行效果应类似地如图1所示，图1中的： 20011 100 80 90 78 85 92 20012 90 83 88 76 80 93 20015 85 50 73 75 83 90 20013 89 80 78 83 75 52 20021 60 82 85 98 75 76 20031 70 70 63 68 93 66 20035 78 60 72 82 88 57 20026 92 85 99 95 65 81 和20035是从键盘输入的内容。

img

#include<stdio.h>

#define NOT_FIND -1
#define TOTAL_STU 8

/* 函数aver的功能为：求学号为stuNo的学生的6门课课程之平均成绩，并通过函数值返回
        若未找到学生stuNo，则返回NOT_FIND */  
float aver(int pStu[TOTAL_STU][7], int stuNo);

int main(void)
{
    int student[TOTAL_STU][7]; /* the first column save student's number */
    float averScore;
    int i, j, stuNumber;

    printf("Input the %d student's number and score: \n", TOTAL_STU);
    /* 本部分代码功能建议：从键盘读入的8个学生的6门课成绩存放在二维数组student中 */ 
    /******start******/

    /******end******/

    printf("Input a student's number to compute: ");
    scanf("%d", &stuNumber);

    averScore = aver(student, stuNumber);
    printf("Output:");
    if (NOT_FIND == averScore)
    {
        printf("\nstudent of No.%d not Find!\n", stuNumber);
    }
    else
    {
        printf("\nThe No.%d student's average is %.2f\n", stuNumber, averScore);
    }

    return 0;
}

/******start******/

/******end******/
#include<stdio.h>

#define NOT_FIND -1
#define TOTAL_STU 8

/* 函数aver的功能为：求学号为stuNo的学生的6门课课程之平均成绩，并通过函数值返回
        若未找到学生stuNo，则返回NOT_FIND */  
float aver(int pStu[TOTAL_STU][7], int stuNo);

int main(void)
{
    int student[TOTAL_STU][7]; /* the first column save student's number */
    float averScore;
    int i, j, stuNumber;

    printf("Input the %d student's number and score: \n", TOTAL_STU);
    /* 本部分代码功能建议：从键盘读入的8个学生的6门课成绩存放在二维数组student中 */ 
    /******start******/
for (i = 0; i < TOTAL_STU; i++)
{
    for (j = 0; j < 7; j++)
    {
        scanf("%d", &student[i][j]);
    }
}
    /******end******/

    printf("Input a student's number to compute: ");
    scanf("%d", &stuNumber);

    averScore = aver(student, stuNumber);
    printf("Output:");
    if (NOT_FIND == averScore)
    {
        printf("\nstudent of No.%d not Find!\n", stuNumber);
    }
    else
    {
        printf("\nThe No.%d student's average is %.2f\n", stuNumber, averScore);
    }

    return 0;
}

/******start******/
float aver(int pStu[TOTAL_STU][7], int stuNo)//离谱,以这种方式把TOTAL_STU传进去
{
    int i, j;
    double sum = 0;
    for (i = 0; i < TOTAL_STU; i++)
    {
        if (pStu[i][0] == stuNo)
        {
            for (j = 1; j < 7; j++)
            {
                sum += pStu[i][j];
            }
            return (float)(sum/6);
        }
    }
    return NOT_FIND;
}

/******end******/
  • 返回float类型,所以定义float类型函数
  1. 程序的功能是：从键盘输入一个整数n(n≥0)和x，计算对应的n阶勒让德多项式Pn(x)的值，并按示例格式输出相应信息。n阶勒让德多项式Pn(x)的定义如下： 　 　　┌　1 (n=0) 　　　　Pn(x)= ├　x (n=1) 　　　　 　　 └((2n-1)xPn-1(x) - (n-1)Pn-2(x)) / n (n>1) 程序的运行效果应类似地如图1所示，图1中的：10, 2是从键盘输入的内容。

img

#include <stdio.h>

/* 本部分代码功能建议：调用相应的函数计算S */
/******start******/

/******end******/
/* 考生添加代码结束 */

int main(void)
{
    double Pnx;
    int n, x;

    printf("please input n, x: ");
    scanf("%d,%d", &n, &x);

    /* 本部分代码功能建议：调用相应的函数计算S */
        /******start******/

    /******end******/
         /* 考生添加代码结束 */

    printf("Output:\nThe answer is %.6f.\n", Pnx);
    return 0;
}

/******start******/

/******end******/
  • 要用一下递归了
#include <stdio.h>

/* 本部分代码功能建议：调用相应的函数计算S */
/******start******/
float ji(int m,int x);
/******end******/
/* 考生添加代码结束 */

int main(void)
{
    double Pnx;
    int n, x;

    printf("please input n, x: ");
    scanf("%d,%d", &n, &x);

    /* 本部分代码功能建议：调用相应的函数计算S */
        /******start******/
Pnx=ji(n,x);

    /******end******/
         /* 考生添加代码结束 */

    printf("Output:\nThe answer is %.6f.\n", Pnx);
    return 0;
}

/******start******/
float ji(int n,int x)
{
    if(n==0)return 1;
    else if(n==1)return x;
    else return ((2*n-1)*x*ji(n-1,x)-(n-1)*ji(n-2,x))/n;

}
/******end******/
  1. 写一个求二次方程ax2+bx+c根的函数。在主函数中首先由键盘输入a、b、c，然后调用求根的函数resolve()求方程的根并输出。需注意b2-4ac大于、等于或小于0的情况。

程序代码中只允许在/start/和/end/之间填写代码，其余部分代码不能修改。输入输出使用：printf("input a b c: "), printf("output:\n"),printf("%.2f %.2f\n", ...)，等。

程序运行的结果如下图：

img

img

img

#include <stdio.h>
#include <math.h>

/******start******/

/******end******/

int main()
{
    double a, b, c=0;
    printf("input a b c: ");
    scanf("%lf%lf%lf", &a, &b, &c);

    resolve(a, b, c);

    return 0;
}

/******start******/

/******end******/
/******start******/
void resolve(double a,double  b,double c);
/******end******/
/******start******/
void resolve(double a,double  b,double c)
{
    double d;
    d=pow(b,2)-4*a*c;
    printf("output:\n");
    if(a==0)
    {
        if(b==0)
            printf("无实数根\n");
        else
            printf("%.2f\n",c/b);
    }
    else if (d<0)
        printf("无实数根\n");
    else if (d==0)
        printf("%.2f\n",-b/(2*a));
    else 
        printf("%.2f %.2f\n",(sqrt(d)-b)/(2*a),-(b+sqrt(d))/(2*a));
}
/******end******/
  1. 请在以下代码中完成判断素数函数的代码。素数是只能被1或自身整除的正整数。

可用输入输出：puts("是素数"), puts("不是素数")。

注意：只允许在/\start\/和/\end\/之间添加代码。

img

#include <stdio.h>

/******start******/

/******end******/

int main()
{
    int x;
    printf("input a integer: ");
    scanf("%d", &x);

    printf("output:\n");
    if(IsShuShu(x))
        puts("是素数");
    else
        puts("不是素数");
}

/******start******/

/******end******/
int IsShuShu(int x);
int IsShuShu(int x)
{
    int i;
    for (i = 2; i < x; i++)
    {
        if (x % i == 0)
        {
            return 0;
        }
    }
    return 1;
}
  1. 从键盘读入一行字符(约定：字符数≤127字节，其中的空格不固定、有多有少)和加密间隔(假定只输入正整数)，将加密后的文字输出。具体加密方法示例为：对于输入“1 2 3 4 5 6 7 8 9abcd ef ghiA BCD EFG HI XYZ”、加密间隔为9，先去掉输入中的空格后输出为：123456789abcdefghiABCDEFGHIXYZ，然后按间隔9分组： 123456789 abcdefghi ABCDEFGHI XYZ 　　输出密码的方法为：从第1组开始，依次从每组各取1字符输出，每一轮取完后输出一个空格，则以上输入的密码输出为：1aAX 2bBY 3cCZ 4dD 5eE 6fF 7gG 8hH 9iI。 　　编程可用素材：printf("Input a string:")...、printf("\nInput jiange:")...、printf("Output:\nThe string of deleted space:")...、printf("\nThe result is:")...。 　　程序的运行效果应类似地如图1所示，图1中的1 2 3 4 5 6 7 8 9abcd ef ghiA BCD EFG HI XYZ和9是从键盘输入的内容。未解决.只有40分

img

  • while(ch=getchar()!='\n')这种写法是错的,应该写成while((ch=getchar())!='\n'),否则程序能运行,但是输出结果是错的
  • getchar接收字符,接收到回车就不收了,回车就被留在了缓冲区,如果后面还有输入的操作就会出问题,所以要清空缓冲区
fflush(stdout);
#include <stdio.h>
#include <string.h>

int main(void)
{
    fflush(stdout);
    char a[100],ch;
    int i=0,q;
    printf("Input a string:");
while((ch=getchar())!='\n')
{
    a[i]=ch;
    if(ch==' ')continue;
    else i++;
}
a[i]='\0';
fflush(stdout);
printf("Input jiange:");
scanf("%d",&q);
printf("Output:\nThe string of deleted space:");
puts(a);

printf("The result is:");
for(int i=0;i<=8;i++)
{
    int q=i;
    while(q<strlen(a))
    {
        printf("%c",a[q]);
        q=q+9;
    //printf(" q=%d ",q);
    }
    printf(" ");

}
fflush(stdout);
    return 0;
}
  1. 要求：不改变单词的顺序的情况下，将每一个单词翻转（单词倒序写）。输入中只有英文单词和空格（不含其它字符）。(未解决)

如图：其中I am happy today是键盘输入的。

img

  1. 将任意十进制正小数分别转换成2,3,4,5,6,7,8,9进制正小数，小数点后保留8位，并输出。例如：若十进制小数为0.795，则输出： 　　　　十进制正小数 0.795000 转换成 2 进制数为: 0.11001011 　　　　十进制正小数 0.795000 转换成 3 进制数为: 0.21011011 　　　　十进制正小数 0.795000 转换成 4 进制数为: 0.30232011 　　　　十进制正小数 0.795000 转换成 5 进制数为: 0.34414141 　　　　十进制正小数 0.795000 转换成 6 进制数为: 0.44341530 　　　　十进制正小数 0.795000 转换成 7 进制数为: 0.53645364 　　　　十进制正小数 0.795000 转换成 8 进制数为: 0.62702436 　　　　十进制正小数 0.795000 转换成 9 进制数为: 0.71348853
#include <stdio.h>

void fun(double dTestNo, int iBase);

int main(void)
{ 
 double dTestNo = 0.795;
 int iBase;

 for (iBase=2; iBase<=9; iBase++)
 {
 fun(dTestNo, iBase);
 }
 printf("\n");

 return 0;
}

void fun(double dTestNo, int iBase)
{
 int iT[8], iNo;

 printf("十进制正小数 %f 转换成 %d 进制数为:", dTestNo, iBase);
 for (iNo=0; iNo<8; iNo++)
 {
 dTestNo *= iBase;
 /*********Found************/
 iT[iNo] = ______________;

 /*********Found************/
 dTestNo -= ______________;

 }

 printf("0.");
 for (iNo=0; iNo<8; iNo++)
 {
 printf("%d", iT[iNo]);
 }
 printf("\n");
}
  • 第一处:int(dTestNo)
  • 第二处:dTestNo -= iT[iNo];
  1. 定义一个整型数组，采用子函数实现数据输入。
\#include<stdio.h>

void input(int a[], int n);

int main(void)
{
 int a[10], i;

 /*********Found************/
 input(a[10], 10);
    /*********End************/

 for (i=0; i<10; i++)
 {
 printf("%d ", a[i]);
 }
 return 0;
}

void input(int a[], int n)
{
 int i;

 for (i=0; i<n; )
 {
 scanf("%d", &a[i]);
 /*********Found************/
 i--;
        /*********End************/
 }
}
  • 第一处:input(a[], 10);
  • 第二处:i++

函数概念

  1. 以下正确的说法是( )。

A)用户若需调用标准库函数，调用前必须重新定义

B)用户可以重新定义标准库函数，若如此，该函数将失去原有含义

C)系统根本不允许用户重新定义标准库函数

D)用户若需调用标准库函数，调用前不必使用预编译命令将该函数所在文件包括到用户源文件中，系统会自动去调

  • b
  1. 下面函数调用语句含有实参的个数为( )。

func((exp1, exp2), (exp3, exp4, exp5));

A)1 B)2 C)4 D)5

  • b
  1. 以下正确的说法是( )。

A)定义函数时，形参的类型说明可以放在函数体内

B)return后边的值不能为表达式

C)如果函数值的类型与返回值类型不一致，以函数值类型为准

D)如果形参与实参的类型不一致，以实参类型为准

  • c
  • 在C语言中,如果函数值的类型和return语句中表达式的值不一致,则会如何?以函数值的类型为准即编译器会自动把return语句中表达式的值的类型转换成函数值
  1. C语言规定，简单变量作为实参时，它和对应形参之间的数据传递方式是( )。

A)地址传递

B)单向值传递

C)由实参传给形参，再由形参传回给实参

D)由用户指定传递方式

  • b
  1. 在C语言的规定中，以下不正确的说法是( )。

A)实参可以是常量、变量或表达式

B)形参可以是常量、变量或表达式

C)形参可以为任意类型

D)实参应与其对应的形参类型一致

  • b
  • 形参只能是变量，在被定义的函数中，必须指定形参的类型。
  1. 以下程序有语法性错误，有关错误原因的正确说法是( )。

main()

{ int G=5, k;

void ptr_char( );

......

k=ptr_char(G);

......

}

A)语句void ptr_char( ); 有错，它是函数调用语句，不能用void说明

B)变量名不能使用大写字母

C)函数说明和函数调用语句之间有矛盾

D)函数名不能使用下划线

  • c
  1. 在C语言程序中以下正确的描述是( )。

A)函数的定义可能嵌套，但函数的调用不可能嵌套

B)函数的定义不可以嵌套，但函数的调用可以嵌套

C)函数的定义和函数的调用不可以嵌套

D)函数的定义和函数的调用均可以嵌套

  • b
  1. 已有以下数组定义和f函数调用语句，则在f函数的说明中，对形参数组array的定义编译报错的为( )。

int a[3][4];

f(a);

A) f(int array[ ][6])

B) f(int array[3][ ])

C) f(int array[ ][4])

D) f(int array[2][5])

  • b
  1. 若使用一维数组名作为函数实参，则以下正确的说法是( )。

A)必须在主调函数中说明此数组的大小

B)实参数组类型与形参数组类型可以不匹配

C)在被调函数中，不需要考虑形参数组的大小

D)实参数组名与形参数组名必须一致

  • a
  1. 以下正确的函数形式是( )。

A)double fun(int x, int y)

{ z=x+y; return z;}

B)fun(int x, y)

{ int z;

return z;}

C)fun(x,y)

{ int x, y; double z;

z=x+y; return z;}

D)double fun(int x, int y)

{ double z;

z=x+y; return z;}

  • d
  1. 若调用一个函数，且此函数中没有return 语句，则正确的说法是( )。

A)该函数没有返回值

B)该函数返回若干个系统默认值

C)该函数能返回一个用户所希望的函数值

D)该函数返回一个不确定的值

  • a
  • 没有return就不返回
  1. C语言规定，函数返回值的类型是由( )。

A)return 语句中的表达式类型所决定

B)调用该函数时的主调函数类型所决定

C)调用该函数时系统临时决定

D)在定义该函数时所指定的函数类型所决定

  • d
  1. 若用数据组名作为函数调用的实参，则传递给形参的是( )。

A)数组的首地址

B)数组第一个元素的值

C)数组中全部元素的值

D)数组元素的个数

  • a
  1. 在C语言中，以下正确的说法是( )。

A)实参和与其对应的形参各占用独立的存储单元

B)实参和与其对应的形参共占用一个存储单元

C)只有当实参和与其对应的形参同名时才共占用存储单元

D)形参是虚拟的，不占用存储单元

  • a
  1. 函数必须有形参。
  • 错

指针其他

  1. 下面程序段的运行结果是( )。

char *p="%d,a=%d,b=%d\n";

int a=111,b=10,c;

c=a%b; p+=3;

printf(p,c,a,b);

A)1,a=111,b=10 B)a=1,b=111 C)a=111,b=10 D)以上结果都不对

  • b
  • p指针存储了字符数组的首地址,p自增3后,指向该数组的第4位,原代码相当于
printf("a=%d,b=%d\n",c,a,b);
  1. 若有说明：char *language[ ]={"FORTRAN", "BASIC", "PASCAL", "JAVA", "C"};则以下不正确的叙述是( )。未解决

A) language+2表示字符串"PASCAL"的首地址

B) *language[2]的值是字母P

C) language是一个字符型指针数组，它包含5个元素，每个元素都是一个指向字符串变量的指针

D) language是一个字符型指针数组，它包含5个元素，其初值分别是："FORTRAN", "BASIC", "PASCAL", "JAVA", "C"

  • d
  1. 若有说明：char *language[ ]={"FORTRAN", "BASIC", "PASCAL", "JAVA", "C"};

则表达式language[1]>language[3]比较的是( )。

A)字符F和字符P B)字符串BASIC和字符串JAVA

C)字符B和字符J D)字符串FORTRAN和字符串PASCAL

  • b
  • 两个指针取了*,得到的是指针指向的字符的值,字符串比较比较的是每一位的ascll码
  1. main函数的正确说明形式是( )。

A) main(int argc, char *argv)

B) main(int abc, char **abv)

C) main(int argc, char argv)

D) main(int c, char v[ ])

  • b
  • 标准格式为main(int argc,char *argv[]);指向指针的指针和指针数组是同一层的
  1. 阅读以下程序：

main()

{ short int a[10] = {2,4,6,8,10,12,14,16,18,20}, *p;

p = a;

printf("%x\n", p);

printf("%x\n", p+9);

}

若假设第一个printf语句输出的是ffca，则第二个printf语句的输出是( )。

A)ffdd B)ffdc C)ffde D)ffcd

  • %x输出的是内存地址
因为指针p所指向的数组元素是short int类型，因此每次指针p加1时，它指向的内存地址会增加2字节。在这个代码中，p指
向a数组的第一个元素，因此第一个printf语句输出的是p的内存地址ffca；第二个printf语句中，p加9后指向a数组的第10
个元素，因此它的内存地址为ffca+9×2=ffde，因此第二个printf语句的输出是ffde。
  1. 若有以下定义，则正确的程序段是( )。

int p, s, i, j;

char *q, ch;

A) main() { *p = 100; ...}

B) main() { p=&ch; s=p; ...}

C) main() { p=&i; q=&ch; p=q; ...}

D) main() { p=&i; q=&ch; p=40; q=*p; ...}

  • d
  • 类型不同的指针不能直接传地址,只能传数值
  1. 若有定义：int a[4][6]; 则能正确表示a数组中任一元素a[i][j]（此处0<=i<4，0<=j<6）地址的表达式是( )。

A)&a[0][0]+6i+j B)a[0][0]+4j+i C)&a[0][0]+4i+j D)&a[0][0]+6j+i

  • a
  1. 若有以下定义，且0<=i<6，则正确的赋值语句是( )。

int s[4][6], t[6][4], (*p)[6];

A)p=t; B)p=s; C)p=s[i]; D)p=t[i];

  • b
  1. 若要对a进行--运算，则a应具有下面说明( )。

A)int p[3]; int *a = p;

B)int k; int *a= &k;

C)char *a[3];

D)int b[10]; int *a=b+1;

  • d
  1. 以下与库函数strcpy(char p1, char p2)功能不相等的程序段是( ).

A)strcpy1(char p1, char p2)

{ while((p1++=p2++)!='\0'); }

B)strcpy1(char p1, char p2)

{ while((p1=p2)!='\0') { p1++; p2++; } }

C)strcpy1(char p1, char p2)

{ while(p2) p1++=*p2++; }

D)strcpy1(char p1, char p2)

{ while(p1++=p2++); }

  • c
strcpy1和strcpy的区别在于，strcpy是C语言库函数，而strcpy1是自定义函数。strcpy函数复制字符串的时候，是从源
字符串的第一个字符开始复制到目标字符串的第一个字符位置，并将源字符串的字符全部复制到目标字符串直到遇到字符串
结束标志（即'\0'）。

而strcpy1函数复制字符串的时候，是从源字符串的第一个字符开始复制到目标字符串的第一个字符位置，但是并不将字符
串结束标志（即'\0'）复制到目标字符串的末尾。因此，使用strcpy1复制字符串之后，可能会造成字符串读取错误的情况。

为了避免上述问题，在实际的程序开发中，我们一般都会使用strcpy函数，而不是自定义的strcpy1函数。
  1. 若有函数max(a,b)，并且已使函数指针变量p指向函数max，当调用该函数时，正确的调用方法是( )。

A) (*p)max(a,b);

B) *pmax(a,b);

C) (*p)(a,b);

D) *p(a,b);

  • c
  1. 以下正确的叙述是( )。

A)C语言允许main函数带形参，且形参个数和形参名均可由用户指定

B)C语言允许main函数带形参，形参名只能是argc和argv

C)C当main函数带有形参时，传给形参的值一般从命令行中得到

D)若有说明：main(int argc, char *argv)，则形参argc的值必须大于1

  • c
  1. 设有以下定义：

char *cc[2]={"1234", "5678"};

则正确的叙述是( )。

A)cc数组的两个元素中各自存放了字符串"1234"和"5678"的首地址

B)cc数组的两个元素分别存放的是含有4个字符的一维字符数组的首地址

C)cc是指针变量，它指向含有两个数组元素的字符型一维数组

D)cc数组元素的值分别是1234和5678

  1. 若有定义：int a[ ]={2,4,6,8,10,12,14,16,18,20,22,24}, *q[4], k; 则下面程序段的输出结果是( )。

for (k=0; k<4; k++) q[k]=&a[k*3];

printf("%d\n", q[3][0]);

A) 8 B) 16 C) 20 D) 输出项不合法，结果不确定

  • b
因为q[3]指向数组a中的第3*3=9个元素，也就是元素16，所以输出结果为16。访问数组元素时，可以使用数组名，也可以使
用指针，如果使用指针，则需要加上下标，而q[3][0]等价于*(q[3]+0)，也就是说，它是通过指针访问数组元素的方法，所
以输出结果为16。
  1. 以下正确的说明语句是( )。未解决

A)int *b[ ]={1,3,5,7,9};

B)int a[5], *num[5]={&a[0], &a[1], &a[2], &a[3], &a[4]};

C)int a[ ]={1,3,5,7,9}; int *num[5]={a[0],a[1],a[2],a[3],a[4]};

D)int a[3][4], (*num)[4]; num[1]=&a[1][3];

  • b
  • 这题有毒,chatgpt都被这题干趴下了
  1. 以下选项中，正确的操作是( )。

A)int a[5], p; p = &a; B)int a[5], p; p=a;

C)int a[5]; int p=a=1000; D)int a[5]; int p1, p2=a; p1=*p2;

  • b
  1. 以下正确的定义语句和赋值语句是( )。未解决

A)int b[3][5], (p)[3], (q)[5]; p=b; q=b;

B)float b[3][5], p[3]; p[0]=b[0]; p[2]=b+4;

C)double b[3][5], s[5][3], *q; q=b; s=q;

D)int b[10], q; char s; q=b; s=b;

  • b
  • chatgbt又被干趴下了🤣他说a是对的哈哈哈哈
这句定义哪里错了呢double b[3][5], s[5][3], *q; q=b; s=q;

该定义的第二句有错误，数组不能直接赋值。您需要使用数组遍历并单独赋值每个元素，才能将一个数组的元素赋值到另一个数组。

正确写法应该是：

double b[3][5], s[5][3], *q;
q=b;
for(int i=0;i<3;i++)
  for(int j=0;j<5;j++)
    s[j][i]=q[i][j];
好的,那么这句呢?int b[3][5], (*p)[3], (*q)[5]; p=b; q=b;

这句定义是没有错误的。

p 和 b 是指向一维数组长度为 3 的指针，q 是指向一维数组长度为 5 的指针，都指向 b。因此，p 和 b 的类型是 int(*p)[3] 和 int(*q)[5]，这表示 p 是一个指针，它指向一个数组，该数组包含三个 int 元素，q 是一个指针，它指向一个数组，该数组包含五个 int 元素。

由于 b 已经是二维数组的首地址，因此 q 和 b 的值相等。
  1. 下面程序应能对两个整型变量的值进行交换。以下正确的说法是( )。

main() { int a=10, b=20; printf("a=%d,b=%d\n", a, b); swap(&a, &b); printf("a=%d,b=%d\n", a, b); } swap(int p, int q) { int t; t=p; p=q; q=t; }

A)该程序完全正确

B)该程序有错，只要将语句swap(&a, &b);中的参数改为a,b即可

C)该程序有错，只要将swap()函数中的形参p和q以及t均定义为指针（执行语句不变）即可

D)以上说法都不正确

  • d
这段代码在swap函数里面改变p和q的值不会影响到main函数里面的a和b的值。为了让swap函数能够交换main函数里面的a和b的值，需要使用指针作为函数参数，将指向变量的地址作为实参传递给函数：

css

#include <stdio.h>

void swap(int *p, int *q)
{
   int t;
   t=*p; *p=*q; *q=t;
}

int main()
{  int a=10, b=20;
   printf("a=%d,b=%d\n", a, b);
   swap(&a, &b);
   printf("a=%d,b=%d\n", a, b);
   return 0;
}

这样，swap函数就可以通过改变指针指向的内存值来改变main函数里面的a和b的值。
  1. 以下程序中调用scanf函数给变量a输入数值的方法是错误的，其错误原因是( )。

main()

{ int p, q, a, b;

p = &a;

printf("input a:");

scanf("%d", *p);

......

}

A)*p表示的是指针变量p的地址

B)*p表示的是变量a的值，而不是变量a的地址

C)*p表示的是指针变量p的值

D)*p只能用来说明p是一个指针变量

  • b
  1. 若有以下定义，且0<=i<4，则不正确的赋值语句是( )。

int b4, p, q[4];

A)q[i]=b[i]; B)p=b; C)p=b[i]; D)q[i]=&b0;

  • b
  1. 已有定义int(*p)( ); 指针p可以( )。

A)代表函数的返回值 B)指向函数的入口地址

C)表示函数的类型 D)表示函数返回值的类型

  • b
  • 背下来就行了
  1. 设有一个名为file1C源程序，且已知命令行为：FILE1 CHINA BEIJING SHANGHAI，则可得以以下运行结果的C源程序为( )。

CHINA

BEIJING

SHANGHAI

A)main(int argc, char *argv[ ])

{ while(--argc>1)

printf("%s%c", *argv, (argc>1)? '\n': ' ');

}

B)main(int argc, char *argv[ ])

{ while(argc-->1)

printf("%s\n", *++argv);

}

C)main(int argc, char *argv[ ])

{ while(++argc>0)

printf("%s%c", *++argv, (argc>1)?' ': '\n');

}

D)main(int argc, char *argv[ ])

{ while(argc>1)

printf("%s", *++argv);

}

  • b
  1. 若有定义：int *p[4]; 则标识符p( )。

A)是一个指向整型变量的指针

B)是一个指针数组名

C)是一个指针，它指向一个含有四个整型元素的一维数组

D)定义不合法

  • b
  1. 以下main函数经过编译、连接后得到的可执行文件名为echo.exe，若希望在系统的命令状态下输入某一命令行后得到的输出是china tianjin，则命令行的内容应是( )。

main(int argc, char *argv[])

{ int i;

for (i=1; i < argc; i++)

printf("%s%c", argv[i], (i<argc-1)? ' ' : '\n');

}

A)china tianjin

B)echo china tinajin

C)echo

china tianjin

D)echo

china

tianjin

  • b
  1. 下面程序段的运行结果是( )。

char *format="%s,a=%d,b=%d\n";

int a=1,b=10;

a+=b;

printf(format,"a+=b",a,b);

A)for,"a+b",ab B)format,"a+=b" C)a+=b,a=11,b=10 D)以上结果都不对

  • c
  • 直接运行吧,学hammer
  1. 若有说明：char *language[ ]={"FORTRAN", "BASIC", "PASCAL", "JAVA", "C"};则language[2]的值是( )。

A)一个字符 B)一个地址

C)一个字符串 D)一个不定值

  • b
  1. 若要对a进行++运算，则a应具有下面说明( )。

A) int a3; B) char *a[ ] = {"12", "ab"};

C) char (a)[3]; D) int b[10], a=b;

  • d
  1. 以下程序有错，错误原因是( )。

main()

{ int p, i; char q, ch;

p = &i;

q = &ch;

*p = 40;

p = q;

......

}

A)p和q的类型不一致，不能执行语句p=q;

B)p中存放的是地址值，因此不能执行语句p=40;

C)q没有指向具体的存储单元，所以*q没有实际意义

D)q虽然指向了具体的存储单元，但该单元中没有确定的值，所以不能执行语句p=q;

  • d
  1. 语句int (*ptr)( ); 的含义是( )。

A) ptr是指向一维数组的指针变量

B) ptr是指向int型数据的指针变量

C) ptr是指向函数的指针，该函数返回一个int型数据

D) ptr是一个函数名，该函数的返回值是指向int型数据的指针

  • c
  1. 已有函数max(a,b)，为了让函数指针变量p指向函数max，正确的赋值方法是( )。

A) p=max B) *p=max;

C) p=max(a,b) D) *p=max(a,b);

  • a
  1. 假如有一个字符串a，通过函数gets键盘输入字符串a，然后把字符串a复制到字符串b，

字符串a的大小不超过30个字符。

要求：采用字符数组进行赋值：例如 b[i]=a[i];

程序运行界面：

img

img

#include <stdio.h>
int main()
{     
    char a[31], b[31];
    int i;

    printf("Please input a string a is:");
    gets(a);
    /******start******/

    /******end******/
    printf("Output:\n");
    printf("string b is:");
    for(i=0;b[i]!='\0';i++)
        printf("%c", b[i]);
    printf("\n");
    return 0;
}
for (i=0; a[i]!='\0';i++)
{
    b[i]=a[i];
}
b[i] = '\0';
  1. 写一个程序，输入月份（1至12的整数），输出该月的英文月份名称。例如，如果输入3，则程序输出March。本题要求使用指针数组进行处理。

输入格式

只有一个整数，保证值在1至12之间（包含1和12）。如果输入不符合要求需有“Input Error!”提示。

各月的标准名称为：January, February, March, April, May, June, July, August, September, October, November, December

输出

输入的月份对应的英文月份名称。 请注意行尾输出换行。

img

img

#include <stdio.h>
int main() {
        char *months[] = {"January", "February", "March",
                "April", "May", "June", "July", "August", "September",
                "October", "November", "December"};
        int month;
        printf("Please input a month number:\n");
        scanf("%d", &month);
        if((month<1)||(month>12))
        {printf("Output:\nInput Error!\n");}
        else
        {
        printf("Output:\nThis month's English name is %s.\n", *(months + month - 1));
        }
        return 0;
}

指针综合程序

  1. 写一个分词函数，提取出一个英文句子中的所有单词，保存到一个单词数组中。另写一个排序函数对字符串数组进行升序排序。在主函数中调用分词函数得到单词数组，调用排序函数对单词排序，然后在主函数中输出各单词。注意：只允许在/\start\/和/\end\/之间添加代码。未完成

约定：

\1. 句子长度不超过200个字母，句子中不超过20个单词。

\2. 句子中英文单词之间只有一个空格，句子结束处是一个英文句点（即小数点）。

规定算法：分词时，当查找空格或句点时，将其替换为字符串终止符，并将单词开始位置的地址保存到指针数组中。

程序运行如下图：

img

#include <stdio.h>
#include <string.h>

int GetWords(char *sentence, char *words[]);
void SortStrings(const char *strs[], int count);

int main()
{
    char str[200];
    int nWords = 0;
    char *words[20];
    int i;

    printf("input a string: ");
    gets(str);

    nWords = GetWords(str, words);
    SortStrings(words, nWords);

    puts("output:");
    for(i=0; i<nWords; i++)
        puts(words[i]);

    return 0;
}

int GetWords(char *str, char *words[])
{
/******start******/

/******end******/
}

void SortStrings(const char *strs[], int count)
{
/******start******/

/******end******/
}
#include <stdio.h>
#include <string.h>

int GetWords(char *sentence, char *words[]);
void SortStrings(const char *strs[], int count);

int main()
{
    char str[200];
    int nWords = 0;
    char *words[20];
    int i;

    printf("input a string: ");
    gets(str);

    nWords = GetWords(str, words);
    SortStrings(words, nWords);

    puts("output:");
    for(i=0; i<nWords; i++)
        puts(words[i]);

    return 0;
}

int GetWords(char *str, char *words[])
{
/******start******/
int i=1;
while(words)
{
    *words[i]=words;
    i++;
}
return words;
/******end******/
}

void SortStrings(const char *strs[], int count)
{
/******start******/

/******end******/
}
  1. 编写程序将两个数按大小输出。注意：请不要修改程序框架和结构，也不允许删除已有任何代码，只允许在/\start\/和/\end\/之间添加代码。

img

#include <stdio.h>

/******start******/

/******end******/
int main()
{
    int a,b;
    printf("Input a, b:");
    scanf("%d,%d",&a,&b);
    printf("Output:\n");
    fun(&a,&b);
    printf("max=%d,min=%d\n", a, b);

    return 0;
}

/******start******/

/******end******/
#include <stdio.h>

/******start******/
void fun(int *a,int *b);
/******end******/
int main()
{
    int a,b;
    printf("Input a, b:");
    scanf("%d,%d",&a,&b);
    printf("Output:\n");
    fun(&a,&b);
    printf("max=%d,min=%d\n", a, b);

    return 0;
}

/******start******/
void fun(int *a,int *b)
{
    int t;
    t=*a;
    *a=*b;
    *b=t;
}
/******end******/

  1. 程序已编写部分代码，请根据程序中的要求完善程序——注意，只能在/\start\/与/\end\/之间添加相代码。

    程序的功能是：从键盘输入两个整数，分别保存到变量numA和numB，调用函数swap()实现numA和numB的交换，并在main函数中输出交换过后的numA和numB。 程序的运行效果应类似地如图1所示，图1中的：3,8是从键盘输入的内容。

img

#include<stdio.h>

/* 本部分代码功能建议：函数原型声明 */
/******start******/

/******end******/

int main(void)
{
    int numA, numB;

    printf("please input a and b: ");
    scanf("%d,%d", &numA, &numB);

    swap(&numA, &numB);
    printf("Output:\na=%d, b=%d\n", numA, numB);

    return 0;
}

/* 本部分代码功能建议：实现子函数swap()，完成a和b的交换 */
/******start******/

/******end******/
#include<stdio.h>

/* 本部分代码功能建议：函数原型声明 */
/******start******/
void fun(int *numA,int *numB);
/******end******/

int main(void)
{
    int numA, numB;

    printf("please input a and b: ");
    scanf("%d,%d", &numA, &numB);

    swap(&numA, &numB);
    printf("Output:\na=%d, b=%d\n", numA, numB);

    return 0;
}

/* 本部分代码功能建议：实现子函数swap()，完成a和b的交换 */
/******start******/
void fun(int *numA,int *numB)
{
int t;
    if(*numA>=*numB)
    {
        t=*numA;
        *numA=*numB;
        *numB=t;
    }
}

/******end******/
  1. 要求通过键盘输入5串字符串，然后调用函数sort完成字符串从小到大排列，然后调用print函数完成字符串输出。

提示：字符串输出可以采用gets函数，未解决

sort函数原型为 void sort(char *name[],int n)

print函数原型为 void print（char *name[ ],int n)

多个字符串可以用字符串指针变量数组来描述

程序界面运行结果：

img

img

#include <stdio.h>

/******start******/

/******end******/
int main()
{
    int a,b;
    printf("Input a, b:");
    scanf("%d,%d",&a,&b);
    printf("Output:\n");
    fun(&a,&b);
    printf("max=%d,min=%d\n", a, b);

    return 0;
}

/******start******/

/******end******/
  1. 在主函数中输入6个字符串，调用另一个函数func对他们按从小到大的顺序排序，然后在主函数中输出这6个已经排好序的字符串。要求使用指针数组进行处理。
\#include <stdio.h>
\#include <string.h>

void func(char *str[]);

int main(void)
{
 int i;
 char s[6][1024], *pStr[6];

 printf("请输入6个字符串：\n");
 for (i=0; i<6; i++)
 {
 gets(s[i]);
 pStr[i] = s[i];
 }

 /*********Found************/
 func(_________);
    /*********End************/

 printf("\n排序后：\n");
 for (i=0; i<6; i++)
 {
 /*********Found************/
 puts(_________);
        /*********End************/

 }

 return 0;
}

void func(char *str[])
{
 int i, j;
 char *temp;

 for (i=0; i<5; i++)
 {
 for (j=i+1; j<6; j++)
 {
  /*********Found************/
  if (strcmp(________________) > 0)
            /*********End************/

  {
  temp = str[j];
  str[j] = str[i];
  str[i] = temp;
  }
 }
 }
}
  • 第一处:func(pStr);
  • 第二处:puts(pStr[i]);
  • 第三处:if (strcmp(str[i], str[j]) > 0)

指针与数组

  1. 若有以下定义，则*(p+5)表示( )。

int a[10], *p=a;

A)元素a[5]的地址 B)元素a[5]的值

C)元素a[6]的地址 D)元素a[6]的值

  • b
  • 第6个元素是a5
  1. 若有以下定义和语句，则对a数组元素地址的正确引用为( )。

int a[2][3], (*p)[3];

p=a;

A) *(p+2) B) p[2] C) p[1]+1 D) (p+1)+2

  • c
如果有以下定义和语句：

int a[2][3], (*p)[3];
p=a;

那么 p[1]+1 表示第二行第二列的元素的地址。

在这种情况下，p 是一个指向含有 3 个 int 元素的数组的指针。它指向二维数组 a 的第一行。因此，p[1] 表示第二行
的开头，也就是第二行第一列的元素的地址。最后，p[1]+1 表示第二行第二列的元素的地址。
  1. 若有定义：int a[5]; 则a数组中首元素的地址可以表示为( )。

A) &a B) a+1 C) a D) &a[1]

  • c
  1. 下面程序段的运行结果是( )。

char *s="abcde";

s+=2; printf("%d", s);

A)cde B)字符c C)字符c的地址 D)无确定的输出结果

  • c
  1. 设有以下程序段：

char str[4][10]={"first","second","third","fourth"}, *strp[4];

int n;

for (n=0; n < 4; n++) strp[n] = str[n];

若k为int型变量且0<=k<4，则对字符串的不正确引用是( )。

A)strp B)str[k] C)strp[k] D)*strp

  • a
这段代码定义了一个字符数组 str，其中包含 4 行，每行有 10 个字符。接下来定义了一个字符指针数组 strp，并为每个
数组元素赋值为 str 数组中对应行的首地址。

换句话说，每个 strp[n] 元素指向 str 数组中的一行，并且存储的是该行的首地址。因此，strp[n] 可以用来指向这行
的第一个字符，并且可以通过索引操作访问该行的其他字符。

这种操作的目的是将二维字符数组的地址转换为一维的字符指针数组，以便在程序中使用更加方便。
  1. 设有下面的程序段：

char s[ ]="china"; char *p; p=s;

则下列叙述正确的是( )。

A)s和p完全相同

B)数组s中的内容和指针变量p中的内容相等

C)s数组长度和p所指向的字符串长度相等

D)*p与s[0]值相等

  • d
是的，*p 和 s[0] 的值是相等的。

在该代码片段中，s 是一个字符数组，包含字符串 "china"。接下来，定义了一个字符指针 p，并将其初始化为指向 s 数组的首地址（即第一个字符）。

因此，*p 的值与 s[0] 的值是相等的，都是字符 'c'。
  1. 若有以下定义，则数值不为3的表达式是( )。

int x[10]={0,1,2,3,4,5,6,7,8,9}, *p1;

A)x[3] B)p1=x+3, p1++ C)p1=x+2,(p1++) D)p1=x+2,*++p1

  • c
  1. 若有以下定义和语句，则对a数组元素的正确引用为( )。

int a[2][3], (*p)[3]

p=a;

A) (p+1)[0] B) ((p+2)+1) C) *(p[1]+1) D) p[1]+2

  • c
  1. 下面程序段中，输出的“*”个数是( )。

char *s="\ta\018bc";

for ( ; s != '\0'; s++) printf("");

A)9 B)5 C)6 D)7

  • c

注意

  • 我已得到明确信息,考试时(做选择题时)拥有编译环境,那么这些类似于代码是否正确的题目直接跑一下就行了,因此指针部分的题目不再做了,直接给答案
  1. 设char *s="\ta\017bc"; 则strlen(s)表达式的值是( )。

A)9 B)5 C)6 D)7

  • b
  1. 以下正确的程序段是( )。

A)char str1[ ]="12345", str2[ ]="abcdef"; strcpy(str1, str2);

B)char str[10], *st="abcde"; strcat(str, st);

C)char str[10]=" ", *st="abcde"; strcat(str,st);

D)char st1="12345", st2="abcde"; strcat(st1, st2);

  • c
  1. 下面程序段的运行结果是( )。

char a[ ]="language", *p;

p=a;

while(p!='u') { printf("%c", p-32); p++; }

A)LANGUAGE B)language C)LANG D)langUAGE

  • c
  1. 下面程序段的运行结果是( )。

char a[ ]="abcdefgh", *p=a;

p+=3;

printf("%d\n", strlen(strcpy(p, "ABCD")));

A)8 B)12 C)4 D)7

  • c
  1. 下面说明不正确的是( )。

A)char a[10]="china"; B)char a[10], *p=a; p="china";

C)char a; a="china"; D)char a[10], p; p=a="china";

  • d
  1. 若有定义char s[10]; 则下面表达式中不表示s[1]的地址的是( )。

A)s+1 B)s++ C)&s[0]+1 D)&s[1]

  • b
  1. 若有定义：int a2; 则对a数组的第i行第j列（假设i, j已正确说明并赋值）元素值的正确引用为( )。

A) ((a+i)+j) B) (a+i)[j] C) (a+i+j) B) (a+i)+j

  • a
  1. 设p1和p2是指向同一个字符串的指针变量，c为字符变量，则以下不能正确执行的赋值语句是( )。

A)c=p1+p2; B)p2=c; C)p1=p2; D)c=p1(*p2);

  • b
  1. 若有定义：int (*p)[4]; 则标识符p ( )。

A)是一个指向整型变量的指针

B)是一个指针数组名

C)是一个指针，它指向一个含有四个整型元素的一维数组

D)说明不合法

  • c
若有定义：int (*p)[4]; 则标识符p是什么呢?

p 是一个指针，它指向一个具有 4 个整数元素的数组。

由定义 int (*p)[4]; 可以知道，p 是一个指向数组的指针，其中数组包含 4 个整数元素。也就是说，p 是一个指向 4 个整数元素的数组的指针。
笑 花狸狐
为什么它不是一个指针数组呢?

因为 p 只指向一个数组，而不是多个数组。一个指针数组通常是一个数组，其中的每个元素都是一个指针。

例如，如果要定义一个指向整数的指针数组，可以使用以下语法：

python

int *ptr[5];

这里，ptr 是一个指针数组，它包含 5 个整数指针。因此，每个元素都是一个指向整数的指针。

相比之下，在 int (*p)[4]; 中，p 仅指向一个数组，其中包含 4 个整数元素，而不是指向多个数组。因此，它不是一个指针数组。
笑 花狸狐
也就是说加上括号,它就不是一个指针数组,而是一个指针了?

是的，您的理解是正确的。

在 C 语言中，括号的优先级是非常重要的。它们决定了表达式的计算顺序。

在本例中，括号决定了该声明定义了一个指向数组的指针，而不是指向指针数组的指针。

更确切地说，它表示了指向一个具有 4 个整数元素的数组的指针，并且该指针可以引用数组中的任意元素。
  1. 下面程序段的运行结果是( )。

char str[ ]="ABC", *p=str;

printf("%d\n", *(p+3));

A)67 B)0 C)字符C的地址 D)字符C

  • b

20 .下面判断正确的是( )。未解决

A)char a="china"; 等价于char a; *a="china";

B)char str[10]={"china"}; 等价于char str[10]; str[ ]={"china"};

C)char s="china"; 等价于char s; s="china";

D)char c[4]="abc", d[4]="abc"; 等价于char c[4]=d[4]="abc";

  • c
A) 不正确，因为字符串字面量是常量，不能通过指针来修改它的值。
B) 不正确，因为第一个语句是使用初始化字符串初始化数组，而第二个语句是通过普通赋值语句来赋值，两者语义不同。
C) 正确，这样写可以初始化指针变量s。
D) 不正确，因为这样写两个数组变量在内存中是独立的，并不能同时初始化。

看不懂
  1. 若有定义：int a[2][3]; 则对a数组的第i行第j列（假设i, j已正确说明并赋值）元素地址的正确引用为( )。

A) (a[i]+j) B) (a+i) C) (a+j) D) a[i]+j

  • d
  1. 若有以下定义，则对a数组元素的正确引用是( )。

int a[5], *p=a;

A)&a[5] B)a+2 C)(p+5) D)*(a+2)

  • d
  1. 下面程序段的运行结果是( )。

char s[6]; s="abcd"; printf(""%s"\n", s);

A)"abcd" B)abcd C)"abcd" D)编译出错

  • d
  1. 以下正确的程序段是( )。

A)char str[20]; scanf("%s", &str);

B)char *p; scanf("%s", p);

C)char str[20]; scanf("%s", &str[2]);

D)char str[20], *p=str; scanf("%s", p[2]);

  • c
  1. 若有以下定义，则对a数组元素地址的正确引用是( )。

int a[5], *p=a;

A)p+5 B)*a+1 C)&a+1 D)&a[0]

  • b
  1. 下面能正确进行字符串赋值操作的是( )。

A)char s[5]={"ABCDE"}; B)char s[5]={'A','B','C','D','E'};

C)char s; s="ABCDE"; D)char s; scanf("%s", s);

  • c
  1. 若有语句：char s1[ ]="string", s2[8], s3, s4="string"; 则正确的语句是( )。

A)strcpy(s1, "string2"); B)strcpy(s4, "string1"); C)strcpy(s3, "string1"); D)strcpy(s2, s1);

  • d
因为s1是一个字符数组，它是常量存储区中的，不能更改。strcpy函数会将后面的字符串复制到s1数组中，但是s1数组是不
能修改的，所以会报错。
是的，这意味着 strcpy 的第一个参数不能是满的字符数组。因为 strcpy 函数把第二个参数的字符串复制到第一个参数所
指的内存中，如果第一个参数已经满了，复制进去的字符可能会导致内存越界，导致程序错误。

28 .若有以下定义，则p+5表示( )。

int a[10], *p=a;

A)元素a[5]的地址 B)元素a[5]的值

C)元素a[6]的地址 D)元素a[6]的值

  • a
  1. 两指针变量相减所得之差是两个指针所指数组元素之间相差的元素个数。
  • 错
两个指针变量相减后得到的差是一个整数，这个整数表示的是这两个指针指向的内存单元的地址差。它的单位是指针类型所
指的内存单元的大小。因此，如果两个指针指向的内存单元是char类型，则它们相减后得到的差表示的是字节数。如果两个
指针指向的内存单元是int类型，则它们相减后得到的差表示的是int大小的倍数。
  1. 假设有一个数组a，整型，有5个元素，通过键盘输入数组各元素，要输出数组各元素的值。

注意：只允许在/\start\/和/\end\/之间添加代码。

程序运行界面

img

#include <stdio.h>

int main()
{
    int a[5];
    int *p,i;
    printf("please enter 5 integer numbers:");
    for(i=0;i<5;i++)
    {
        scanf("%d",&a[i]);
    }
    printf("Output:\n");
    /******start******/

    /******end******/
    {
        printf("%d ",*p);
    }
    printf("\n");
    return 0;
}
#include <stdio.h>

int main()
{
    int a[5];
    int *p,i;
    printf("please enter 5 integer numbers:");
    for(i=0;i<5;i++)
    {
        scanf("%d",&a[i]);
    }
    printf("Output:\n");
    /******start******/
    p=a;

    for(i=0;i<5;i++,p++)
    /******end******/
    {
        printf("%d ",*p);
    }
    printf("\n");
    return 0;
}
  1. 假设有一个数组a，整型，有5个元素，通过键盘输入数组各元素，要输出数组各元素的值。

要求：采用指针法，如*(a+i)形式输出数组各元素,其中a为数组名

程序运行结果如下：

img

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int *a;
    int i;

    printf("please enter 5 integer numbers:");
    /******start******/ 

    /******end******/   
    for(i=0;i<5;i++)
    {
        /******start******/

        /******end******/
    }
    printf("Output:\n");
    for(i=0;i<5;i++)
    {
        /******start******/

        /******end******/
    }
    printf("\n");
    return 0;
}
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int *a;
    int i;

    printf("please enter 5 integer numbers:");
    /******start******/ 
int b[10];
a=b;
for(int i=1;i<=5;i++,a++)
{
scanf("%d",a);
}
    /******end******/   
    for(i=0;i<5;i++)
    {
        /******start******/
    a=b;
        /******end******/
    }
    printf("Output:\n");
    for(i=0;i<5;i++)
    {
        /******start******/
printf("%d ",*(a+i));

        /******end******/
    }
    printf("\n");
    return 0;
}
  1. 假设有一个数组a，整型，有5个元素，通过键盘输入数组各元素，要输出数组各元素的值。

要求：采用数组下标法，如a[i]形式输出数组各元素

程序运行界面如下：

img

#include <stdio.h>
int main()
 {
    int a[5];
    int i;
     printf("please enter 5 integer numbers:");
       for(i=0;i<5;i++)
    scanf("%d",&a[i]);
     printf("Output:\n");
     for(i=0;i<5;i++)
    printf("%d ",a[i]);
       printf("\n");
    return 0;
 }

指针变量

  1. 已有变量定义和函数调用语句：int a=25; print_value(&a); 下面函数的正确输出结果是( )。

void print_value(int *x)

{ printf("%d\n", ++*x); }

A)23 B)24 C)25 D)26

  • a
  1. 若有说明：int *p, m=5, n; 以下正确的程序段是( )。

A)p = &n; scanf("%d', &p);

B)p=&n; scanf("%d", *p);

C)scanf("%d", &n); *p=n;

D)p=&n; *p=m;

  • d
  1. 若已定义int a=5; 下面对(1)、(2)两个语句的正确解释是( )。

(1)int p=&a; (2)p=a;

A)语句(1)和(2)中的*p含义相同，都表示给指针变量p赋值

B)(1)和(2)语句的执行结果，都是把变量a的地址值赋给指针变量p

C)(1)在对p进行说明的同时进行初始化，使p指向a

(2)将变量a的值赋给指针变量p

D)(1)在对p进行说明的同时进行初始化，使p指向a

(2)将变量a的值赋给*p

  • d
所以简单地说，(1) 将变量 a 的地址赋给了指针变量 p，(2) 将变量 a 的值赋给了 *p。
  1. 有四组对指针变量进行操作的语句，以下判断正确的选项是( )。

(1) int p, q; q=*p;

int a, p, q; p=q=&a;

(2) int a, p, q; q=&a; p=*q;

int a=20, p; p=a;

(3) int a=b=0, p; p=&a; b=p;

int a=20, p, q=&a; p=q;

(4) int a=20, p, q=&a; p=q;

int p, q; q=&p;

A)1正确，234不正确

B)14正确，23不正确

C)3正确，124不正确

D)以上结论都不正确

  • d
(1) 第一组是错误的，因为对于q=*p，p是一个未初始化的指针，因此程序存在不确定的行为。
第二组是正确的。
(2) 第一组是错误的，因为对于p=q，q是一个指向整数的指针，因此程序存在不确定的行为。
第二组是错误的，因为p是一个未初始化的指针，因此程序存在不确定的行为。
(3) 第一组是正确的。
第二组是错误的，因为p是一个未初始化的指针，因此程序存在不确定的行为。
(4) 两组都是正确的。

对于   int a=20, \*p, \*q=&a; \*p=*q;
这句代码是错误的，因为指针变量p没有分配内存地址，它不指向任何变量，因此将q的值赋给p是不安全的，可能导致程序
的崩溃。在使用指针前，应该先分配内存地址，并且对指针进行初始化。例如，在此之前可以使用p=&a进行初始化。
  1. 若有语句int *point, a=4; 和point=&a; 下面均代表地址的一组选项是( )。

A)a, point, &a B)&a, &a, point C)&point, point, &a D)&a, &point, point

  • d
  1. 若需要建立如图所示的存储结构，且已有说明float *p, m=3.14; 则正确的赋值语句是( )。

c6010.JPG

A)p=m; B)p=&m; C)p=m; D)p=&m;

  • b
  1. 已有定义int k=2; int ptr1, ptr2; 且ptr1和ptr2均已指向变量k，下面不能正确执行的赋值语句是( )。

A)k=ptr1+ptr2; B)ptr2=k; C)ptr1=ptr2; D)k=ptr1(*ptr2);

  • b
  1. 若有以下定义和语句，则选项中错误的语句是( )。

int a=4, b=3, p, q, *w;

p=&a; q=&b; w=q; q=NULL;

A)q=0; B)w=p; C)p=a; D)p=w;

  • a
w=q仅仅是不安全的,不是不可以

在上面的条件下，如果再加上 *q=0，则该语句就是错误的。因为在上面代码中，q 已经被赋值为NULL，对NULL执行读写操作是不合法的。

例如：

int a=4, b=3, *p, *q, *w;
p=&a; q=&b; w=q; q=NULL; *q=0;

在这种情况下，代码将出现运行错误，因为对一个空指针进行读写操作是不合法的。
  1. 有如下语句int a=10, b=20, p1, p2; p1=&a; p2=&b; 如左图所示；若要实现右图所示的存储结构，可选用的赋值语句是( )。

c6005.JPG

A)p1=p2; B)p1=p2; C)p1=p2; D)p1=p2;

  • b
  1. 若有说明语句，则以下不正确的叙述是( )。

char a[ ]="It is mine";

char *p="It is mine";

A)a+1表示的是字符t所在存储单元的地址

B)p指向另外的字符串时，字符串的长度不受限制

C)p变量中存放的地址值可以改变

D)a中只能存放10个字符

  • d
  1. 若有说明：int p1, p2, m=5, n; 以下赋值语句全部都是正确的的选项是( )。

A) p1=&m; p2=&p1;

B) p1=&m; *p2=m;

C) p1=&m; p2=p1;

D) p1=&m; p2=p1;

  • c

12 .若有以下说明和语句：未解决

char *language[ ]={"FORTRAN", "BASIC", "PASCAL", "JAVA", "C"};

char **q; q=language+2;

则语句printf("%o\n", *q);__**_**。

A)输出的是language[2]地址

B)输出的是字符串PASCAL

C)输出的是language[2]元素的值，它是字符串PASCAL的首地址

D)格式说明不正确，无法得到确定的输出

  • c
  • 又把chatgpt考到了
  1. char *s="C Language";表示s是一个指向字符串的指针变量，把字符串的首地址赋予s。
  • 对
  1. 内存中的每个存储单元都有一个唯一的地址。
  • 对
  1. 取地址运算符&与指针运算符*的优先级相同，结合方向为自右向左。
  • 对
这句话告诉我们，在 C 语言中，取地址运算符 & 和指针运算符 * 的优先级是相同的。也就是说，当一个表达式同时包
含 & 和 * 运算符时，先执行从右往左的结合。换句话说，如果一个表达式是 & *p，它是先对 *p 进行求值，再求该表
达式的地址。
  1. 指针变量和它指向的变量之间的关系，可以用指针运算符“*”表示。
  • 对
  1. 通过键盘输入两整型变量a和b，然后定义俩指针变量p1和p2指向整型变量a和b，

然后a和b之间相互比较，a若小于b，则调用函数swap，实现a和b两数交换，

然后在按大小顺序输出。注意：只允许在/\start\/和/\end\/之间添加代码。

运行结果如下：

img

img

#include <stdio.h>

/******start******/
void swap(int *p1,int *p2);
/******end******/

int main()
{
      int a,b;
      int*pointer_1,*pointer_2;
      printf("please enter a and b:");
      scanf("%d,%d",&a,&b);
      pointer_1=&a;
      pointer_2=&b;
      if(a<b) swap(pointer_1,pointer_2);
      printf("Output:\nmax=%d,min=%d\n",a,b);
      return 0;
 }    

/******start******/
void swap(int *p1,int *p2);
{
int *t;
    if(*p1<=*p2)
    {
        t=*p1;
        *p1=*p2;
        *p2=t;
    }
}
/******end******/
#include <stdio.h>

/******start******/
void swap(int *p1,int *p2);
/******end******/

int main()
{
      int a,b;
      int*pointer_1,*pointer_2;
      printf("please enter a and b:");
      scanf("%d,%d",&a,&b);
      pointer_1=&a;
      pointer_2=&b;
      if(a<b) swap(pointer_1,pointer_2);
      printf("Output:\nmax=%d,min=%d\n",a,b);
      return 0;
 }    

/******start******/
void swap(int *p1,int *p2)
{
int t;

        t=*p1;
        *p1=*p2;
        *p2=t;

}
/******end******/
  • 注意:下面的写法是不对的未解决
void swap(int *p1,int *p2)
{
int *t;

        t=*p1;
        *p1=*p2;
        *p2=t;

}
/******end******/
  1. 程序功能：将字符串输出到屏幕。注意：只修改/****Found***/下面一行。
\#include<stdio.h>

int main(void)
{
    /*********Found************/
    char yy[200] = "ok??";

    /*********Found************/
    fol (; *yy; yy++)
    {
        putchar(*yy);
    }

 return 0;
}
  • 第一处:char *yy= "ok??";
  • 第2处:for (; *yy; yy++)
  1. 程序功能：动态分配内存，将分配的内存地址输出。注意：只修改/****Found***/下面一行。
\#include<stdio.h>
\#include<stdlib.h>

int main(void)
{
    /*********Found************/
    char pch[2];

    /*********Found************/
    if (pch = (char *)malloc(100) == NULL) 

    {
        printf("malloc memory fail!\n");
        return 1;
    }
    printf("%p\n", pch);

    /*********Found************/
    close(pch);

 return 0;
}
  • 第一处:char pch;
  • 第2处:(pch = (char *)malloc(100))
  • 第3处:free(pch);
  1. 程序功能：交换输出两数。注意：只修改/****Found***/下面一行。
\#include<stdio.h>

void swap(int *x, int *y);

int main(void)
{
    int a = 3, b = 4;

    /*********Found************/
    swap(*a, *b);
    /*********Found************/
    printf("a=%d b=%d\n", &a, &b);

 return 0;
}

void swap(int *x, int *y)
{
    int *tmp, tsX;

    /*********Found************/
    *tmp = x;
    *x = *y;
    /*********Found************/
    *y = *tmp;
}
  • 第一处:swap(&a, &b);
  • 第2处:printf("a=%d b=%d\n", a, b);
  • 第3处: tmp = *x;
  • 第4处: *y=tmp;

结构体

  1. 下列关于结构的说法错误的是( )。

A)结构是由用户自定义的一种数据类型

B)结构中可设定若干个不同数据类型的成员

C)结构中成员的数据类型可以是另一个已定义的结构

D)在定义结构时，可以为成员设置默认值

  • d
  1. 设有以下说明语句：

struct stu

{ int a;

float b;

} stutype;

则下面的叙述不正确的是( )。

A)struct是结构体类型的关键字

B)struct stu是用户定义的结构体类型名

C)stutype是用户定义的结构体类型名

D)a和b都是结构体成员名

  • c
  • struct是类型关键字,struct stu是类型名,stutype是结构体变量名
  1. 若有以下定义和语句：

struct student

{ int age;

int num;

};

struct student stu[3]={{1001,20}, {1002, 19}, {1003, 21}};

main( )

{ struct student *p;

p=stu;

......

}

则以下不正确的引用形式是( )。

A) (p++)->num B) p++

C) (*p).num D) p=&stu.age

  • d
  1. 以下关于结构体的叙述中，错误的是( )。

A)结构体是一种可由用户构造的数据类型

B)结构体中的成员可以具有不同的数据类型

C)结构体中的成员不可以与结构体变量同名

D)结构体中的成员可以是指向自身结构的指针类型

  • c
  1. 设有以下定义和语句，以下引用形式不合法的是( )。未解决

struct s

{ int i1;

struct s i2, i0;

};

static struct s a[3]={2, &a[1], '\0', 4, &a[2], &a[0], 6, '\0', &a[1]}, *ptr;

ptr=a;

A) ptr->i1++ B) ptr->i2 C) ++ptr->i0 D) ptr->i1

  1. 已知学生记录描述为：

struct student

{ int no;

char name[20];

char sex;

struct

{ int year;

int month;

int day;

} birth;

};

struct student s;

设变量s中的“生日”应是“1984年11月11日”，下列对“生日”的正确赋值方式是( )。

A) year = 1984; month = 11; day = 11;

B) birth.year = 1984; birth.month = 11; birth.day=11;

C) s.year=1984; s.month=11; s.day=11;

D) s.birth.year=1984; s.birth.month=11; s.birth.day=11;

  • d
  1. C语言结构体类型变量在其生存期间( )。

A)所有成员一直驻留在内存中

B)只有一个成员驻留在内存中

C)部分成员驻留在内存中

D)没有成员驻留在内存中

  • a
  1. 若有以下声明语句：

typedef struct

{ int n;

struct {int y, m, d; } date;

} PERSON;

则下面定义结构体数组并赋值的语句中错误的是( )。

A) PERSON x[2]={1,04,10,1,2,04,12,30};

B) PERSON x[2]={{1,04,10,1},{2,04,12,30}};

C) PERSON x[2]={1, {04,10,1}, 2, {04,12,30}};

D) PERSON x[2]={{1}, 04,10,1,{2}, 04, 12, 30};

  • d
  • 按顺序插入也是可以的
  1. 若有以下说明和语句，则对pup中sex域的正确引用方式是( )。

struct pupil

{ char name[20];

int sex;

} pup, *p;

p=&pup;

A) p.pup.sex B) p->pup.sex C) (p).pup.sex D) (p).sex

  • d
  1. 以下结构体类型说明和变量定义中，正确的是( )。

A)

struct SS

{ char flag;

float x;

}

struct SS a,b;

B)

struct

{ char flag;

float x;

} SS;

SS a,b;

C)

struct ss

{ char flag;

float x;

};

struct ss a,b;

D)

typedef

{ char flag;

float x

} SS;

SS a,b;

  • c
  1. 以下scanf函数调用语句中对结构体变量成员的引用，错误的是( )。

struct pupil

{ char name[20];

int age;

int sex;

} pup[5];

A) scanf("%s", pup[0].name);

B) scanf("%d", &pup[0].age);

C) scanf("%d", &(pup->sex));

D) scanf("%d", pup->age);

  • a
  • ->的意思是访问结构体指针的成员变量
  1. 若有以下程序段：

struct dent

{ int n;

int *m;

};

int a=1, b=2, c=3;

struct dent s[3]={{101, &a}, {102, &b}, {103, &c}};

main( )

{ struct dent *p;

p=s;

......

}

则以下表达式中值为2的是( )。

A) (p++)->m B) (p++)->m C) (p).m D) *(++p)->m

  • d
  1. 以下对结构体类型变量st的定义中，不正确的是( )。

A) struct { char c; int a; } st;

B) struct { char c; int a; } TT;

struct TT st;

C) typedef struct {char c; int a; } TT;

TT st;

D) struct TT { char c; int a; } st;

  • b
  1. 设有以下语句：未解决

typedef struct REC

{

char c; int a[4];

} REC1;

则下面叙述中正确的是( )。

A) 可以这样定义变量：REC rec;

B) REC1是struct REC类型的变量

C) REC是struct类型的变量

D) 可以用REC1定义结构体变量

  • d
  1. 若有以下说明和语句，则下面表达式中值为1002的是( )。

struct student

{ int num;

int age;

};

struct student stu[3]={{1001, 20}, {1002, 19}, {1003, 21}};

struct student *p;

p=stu;

A) (p++)->age B) (p++)->num C) (p).age D) (++p).num

  • d
  1. 若有如下定义：

struct person

{ int id; char name[10]; } per, *s= &per;

则以下对结构体成员的引用中错误的是( )。

A) per.name B) s->name[0]

C) (per).name[8] D) (s).id

  • c
  1. 若有以下说明和语句：

struct student

{ int age;

int num;

} std, *p;

p=&std;

则以下对结构体变量std中成员age的引用方式不正确的是( )。

A) std.age B) p->age C) (p).age D) p.age

  • d
  1. 设有如下定义：

struct REC

{ int num;

char flag;

char adr[20];

} rec[10], *pr=rec;

下面各输入语句错误的是( )。

A) scanf("%s", &rec.adr); B) scanf("%d", &(*pr).num);

C) scanf("%c", &(pr->flag)); D) scanf("%c", &rec[1].flag);

  • a
  1. 根据下面的定义，能打印出字母M的语句是( )。

struct person {char name[9];

int age;

};

struct person class[10] = {"John", 17, "paul", 19, "Mary", 18, "adam", 16};

A) printf("%c\n", class[3].name);

B) printf("%c\n", class[3].name[1]);

C) printf("%c\n", class[2].name[1]);

D) printf("%c\n", class[2].name[0]);

  • d
  1. 设有以下说明和定义语句，则下面表达式中值为3的是( )。

struct s

{ int i1;

struct s *i2;

};

static struct s a[3]={1, &a[1], 2, &a[2], 3, &a[0]}, *ptr;

ptr=&a[1];

A) ptr->i1++ B) ptr++->i1 C) *ptr->i1 D) ++ptr->i1

  • d
  1. 结构体类型本身不占用内存空间，结构体变量占用内存空间。
  • 对
  1. 结构体成员的类型必须是基本数据类型。
  • 错
  1. 共用体变量不可以进行初始化。
  • 对
  1. 枚举类型中的元素都具有一个整型值。
  • 对
  1. 用一维数组存储学号和成绩，然后，按成绩排序输出。

输入格式

输入第一行包括一个整数N(1<=N<=100)，代表学生的个数。 接下来的N行每行包括两个整数p和q，分别代表每个学生的学号和成绩。

输出

按照学生的成绩从小到大进行排序，并将排序后的学生信息打印出来。 如果学生的成绩相同，则按照学号的大小进行从小到大排序。

样例输入

img

img

#include <stdio.h>
struct stu
{
    int id[10];
    int sco[10];
}stu1;

int main() {

       int n,ch;
       scanf("%d",&n);
       for(int i=1;i<=n;i++)
       {
            scanf("%d %d",&stu1.id[i],&stu1.sco[i]);
       }

       for(int i=1;i<=n;i++)
       {
            for(int t=i;t<=n;t++)
            {
                if(stu1.sco[i]>stu1.sco[t])
                {
                    ch=stu1.sco[i];
                    stu1.sco[i]=stu1.sco[t];
                    stu1.sco[t]=ch;

                    ch=stu1.id[i];
                    stu1.id[i]=stu1.id[t];
                    stu1.id[t]=ch;

                }
                if((stu1.sco[i]==stu1.sco[t])&&(stu1.id[i]>stu1.id[t]))
                {
                    ch=stu1.sco[i];
                                        stu1.sco[i]=stu1.sco[t];
                                        stu1.sco[t]=ch;

                                        ch=stu1.id[i];
                                        stu1.id[i]=stu1.id[t];
                                        stu1.id[t]=ch;
                }
            }
       }

       printf("Output:\n");
       for(int i=1;i<=n;i++)
        {
                printf("%d %d\n",stu1.id[i],stu1.sco[i]);
        }

        return 0;
}

  1. 输入输出n个职员的基本信息（如图所示）。注意：只允许在/\start\/和/\end\/之间添加代码。 其中：

    3

1001 zhao 100

1002 qian 150

1003 sun 130

是键盘输入的。

img

#include<stdio.h>

/******start******/

/******end******/   

    printf("Output:\n");
    printf("number\tname\tprize\n");
    for (i = 0; i < n; i++)
    {
        printf("%d\t", em[i].number);
        printf("%s\t", em[i].name);
        printf("%.2f\n", em[i].prize);
    }

    return 0;
}
  • 申请别名必须要typedef
#include<stdio.h>

/******start******/
typedef struct _employee
{
    int number;
    char name[20];
    double prize;
} Employee;

int main(void)
{
    int i, n;
    Employee em[50];

    printf("Input the number(<50):\n");
    scanf("%d", &n);
    printf("Input the info:\n");
    for (i = 0; i < n; i++)
    {
        scanf("%d%s%lf", &em[i].number, em[i].name, &em[i].prize);
    }
/******end******/   

    printf("Output:\n");
    printf("number\tname\tprize\n");
    for (i = 0; i < n; i++)
    {
        printf("%d\t", em[i].number);
        printf("%s\t", em[i].name);
        printf("%.2f\n", em[i].prize);
    }

    return 0;
}

  1. 完成一个对候选人得票的统计程序。假设有3个候选人，名字分别为Li，Zhang和Fun。使用结构体存储每一个候选人的名字和得票数。记录每一张选票的得票人名，输出每个候选人最终的得票数。结构体可以定义成如下的格式： struct person { char name[20]; int count; }leader[3] = {"Li", 0, "Zhang", 0, "Fun", 0};

    输入格式

    第一行有一个整数n，表示以下有n张选票信息将会输入。保证n不大于100。 以后的n行中，每一行包含一个人名，为选票的得票人。保证每一个人名都是Li，Zhang和Fun中的某一个。

    输出

    有三行，分别为Li，Zhang和Fun每人的得票数。格式为首先输出人名，其后输出一个冒号，最后输出候选人的得票数。 请注意行尾输出换行。

样例如图：

img

/******start******/

/******end******/
    printf("Output:\nThe result is:\n");
    for (i = 0;i < 3;i++)
    {
        printf("%s:%d\n", leader[i].name, leader[i].count);
    }
    return 0;
}
  • 比较字符串只能strcmp()
#include <stdio.h>
#include <string.h>
struct person {
        char name[20];
        int count;
}leader[3] = {"Li", 0, "Zhang", 0, "Fun", 0};
int main() {
        int n, i, j;
        char leader_name[20];
        printf("Please input total number:\n");
        scanf("%d", &n);
        printf("Please input the candidate's name:\n");
        for (i = 0;i < n;i++) {
                scanf("%s", leader_name);
                for (j = 0;j < 3;j++)
                        if (strcmp(leader_name, leader[j].name) == 0)
                                leader[j].count++;
        }
//LB审核

    printf("Output:\nThe result is:\n");
    for (i = 0;i < 3;i++)
    {
        printf("%s:%d\n", leader[i].name, leader[i].count);
    }
    return 0;
}
  1. 设有10名歌手(编号为1-10)参加歌咏比赛，另有6名评委打分，每位歌手的得分从键盘输入：先提示“Please input singer's score: ”，再依次输入第1个歌手的6位评委打分(10分制，分数为整型，分数之间使用空格分隔)，第2个歌手的6位评委打分...以此类推。计算出每位歌手的最终得分(扣除一个最高分和一个最低分后的平均分，最终得分保留2位小数)，最后按最终得分由高到低的顺序输出每位歌手的编号及最终得分

img

img

img

#include <stdio.h>

typedef struct _singer
{
    int number;
    int score[6];
    float average;
} singer;

int main(void)
{
    int i, j, sum, min, max;
    singer temp;
    singer people[10];

    for (i = 0; i < 10; i++)
    {
        people[i].number = i + 1;
    }

    printf("Please input singer's score: ");
    for (i = 0; i < 10; i++)
    {
        for (j = 0; j < 6; j++)
        {
            scanf("%d", &people[i].score[j]);

            if(people[i].score[j] > 10 || people[i].score[j] < 0)
            {
                printf("output:\n成绩必须为10分制:\n");
                return 0;
            }
        }
    }

    //求平均成绩
    for (i = 0; i < 10; i++)
    {
        sum = 0;
        min = max = people[i].score[0];
        for (j = 0; j < 6; j++)
        {
            if (min > people[i].score[j])
            {
                min = people[i].score[j];
            }
            if (max < people[i].score[j])
            {
                max = people[i].score[j];
            }

            //计算总成绩
            sum = sum + people[i].score[j];
        }

        people[i].average = (float)((sum - min - max) / 4.0);
    }

    //排序
    for (i = 0; i < 10; i++)
    {
        for (j = 0; j < 10 - i - 1; j++)
        {
            if (people[j].average < people[j + 1].average)
            {
                temp = people[j];
                people[j] = people[j + 1];
                people[j + 1] = temp;
            }
        }
    }

    //成绩输出
    printf("output:\nscores:\n");
    for (i = 0; i < 10; i++)
    {
        printf("No.%d:%.2f\n", people[i].number, people[i].average);
    }

    return 0;
}
  1. 输入输出动物园的n个动物的基本信息（如图所示）。注意：只允许在/\start\/和/\end\/之间添加代码。

其中：

2

1 snake 9

2 monkey 23

是键盘输入的。

注意：Input the number 之后是(<50)。

img

#include<stdio.h>

struct animal
{
/******start******/

/******end******/   

    printf("Output:\n");
    printf("No\tname\tnumber\n");
    for (i = 0; i < n; i++)
    {
        printf("%d\t", ani[i].No);
        printf("%s\t", ani[i].name);
        printf("%d\n", ani[i].count);
    }

    return 0;
}
/******start******/
    int No;
    char name[20];
    int count;
};
int main(void)
{
    struct animal ani[50];
    int i, n;

    printf("Input the number(<50):\n");
    scanf("%d", &n);
    printf("Input the info:\n");
    for (i = 0; i < n; i++)
    {
        scanf("%d%s%d", &ani[i].No, ani[i].name, &ani[i].count);
    }
/******end******/
  1. 输入输出一个学生的基本信息（如图所示）。注意：只允许在/\start\/和/\end\/之间添加代码。 其中： 1001 zhang 19 87.5

是键盘输入的。

img

#include<stdio.h>

/******start******/

/******end******/

int main(void)
{
    struct student st1;

    printf("Input the info:\n");
    scanf("%d%s%d%lf", &st1.number, st1.name, &st1.age, &st1.score);

    printf("Output:\n");
    /******start******/

    /******end******/
    return 0;
}
#include<stdio.h>

/******start******/

/******end******/

int main(void)
{
    struct student st1;

    printf("Input the info:\n");
    scanf("%d%s%d%lf", &st1.number, st1.name, &st1.age, &st1.score);

    printf("Output:\n");
    /******start******/

    /******end******/
    return 0;
}
  1. 程序功能：输入输出结构体数据。注意：只修改/****Found***/下面一行。
\#include<stdio.h>

int main(void)
{
    struct WKER
    {
        long ID;
        int num;
        char name[20];
        char sex;
    /*********Found************/
    } ;

    worker2.ID = 1L;
    /*********Found************/
    scanf("%s %s %s", &worker2.num, worker2.name, &worker2.sex);
    /*********Found************/
    printf("worker's info: num=%s name=%s sex=%s\n", worker2.num, worker2.name, worker2.sex);

 return 0;
}
  • 第一处:删去;
  • 第二处:scanf("%i %s %c", &worker2.num, worker2.name, &worker2.sex);
  • 第三处:printf("worker's info: num=%i name=%s sex=%c\n", worker2.num, worker2.name, worker2.sex);
  1. 从一个子函数中输入结构体信息并在主函数中输出。
\#include <stdio.h>
\#include <stdlib.h>

struct aa
{
 int a;
 double b;
};

/*********Found************/
void Input(struct aa x);
/*********End************/

int main(void)
{
 struct aa y;

 /*********Found************/
 Input(y);
    /*********End************/

 printf("%d %f\n", y.a, y.b);
 return 0;
}

/*********Found************/
void Input(struct aa x)
/*********End************/

{
 char tmp[10];

 printf("请输入整型数a:");
 gets(tmp);
 x->a = atoi(tmp);
 printf("请输入单精度数b:");
 gets(tmp);
 x->b = atof(tmp);
}
  • 第一处:void Input(struct aa *x);传结构体需要传地址
  • 第二处:Input(&y);
  • 第三处:void Input(struct aa *x);传结构体需要传地址

文件概念

  1. 若有下列定义和说明：

#include

struct std

{ char num[6];

char name[8];

float mark[4];

} a[30];

FILE *fp;

则以下不能将文件内容读入数组a中的语句组是( )。

A) for (i=0; i<30; i++)

fread(&a[i], sizeof(struct std), 1L, fp);

B) for(i=0; i<30; i++, i++)

fread(&a[i], sizeof(struct std), 2L, fp);

C) fread(a, sizeof(struct std), 30L, fp);

D) for (i=0; i<30; i++)

fread(a[i], sizeof(struct std), 1L, fp);

  • d
  1. 若调用fputc函数输出字符成功，则其返回值是( )。

A)EOF B)1 C)0 D)输出的字符

  • d
  1. 函数调用语句fseek(fp, -20L, 2); 的含义是( )。

A)将文件位置指针移到距离文件头20个字节处

B)将文件位置指针从当前位置向后移动20个字节

C)将文件位置指针从文件末尾向后退20个字节

D)将文件位置指针移到离当前位置20个字节处

  • c
fseek函数的第三个参数有三种：

SEEK_SET：从文件开头开始定位。

SEEK_CUR：从当前文件指针位置定位。

SEEK_END：从文件末尾开始定位。
  1. 函数rewind的作用是( )。

A)使位置指针重新返回文件的开头

B)将位置指针指向文件中所要求的特定位置

C)使位置指针指向文件的末尾

D)使位置指针自动移至下一个字符位置

  • a
wind 函数的作用是将文件指针重置到文件的开头。它通过调用 fseek 函数，将文件指针移动到文件的开头，即偏移量设置
为 0，同时将文件状态标志清除
  1. 若执行fopen函数时发生错误，则函数的返回值是( )。

A)地址值 B)0 C)1 D)EOF

  • b
  1. fgetc函数的作用是从指定文件读入一个字符，该文件的打开方式必须是( )。

A)只写 B)追加 C)读或读写 D)答案B和C都正确

  • c
  1. fscanf函数的正确调用形式是( )。

A) fscanf(文件指针, 格式字符串, 输出表列);

B) fscanf(格式字符串, 输出表列, 文件指针);

C) fscanf(格式字符串, 文件指针, 输出表列);

D) fscanf(文件指针, 格式字符串, 输入表列);

  • d
fscanf函数的正确调用形式是：

int fscanf(FILE *stream, const char *format, ...);

其中，stream 代表文件指针，format 代表输入格式，... 代表输入数据的地址。

例如：

c

FILE *fp;
int a, b, c;
fp = fopen("data.txt", "r");
fscanf(fp, "%d%d%d", &a, &b, &c);

此代码将从文件 "data.txt" 中读取三个整数，存储到变量 a, b, c 中。
  1. 在执行fopen函数时，ferror函数的初值是( )。

A)TRUE B)-1 C)1 D)0

  • d
  1. 已知函数的调用形式：fread(buffer, size, count, fp); 其中buffer代表的是( )。

A)一个整型变量，代表要读入的数据项总数

B)一个文件指针，指向要读的文件

C)一个指针，指向要读入数据的存放地址

D)一个存储区，存放要读的数据项

  • c
buffer代表的是一个指向存储读取数据的内存区域的指针。它将接收从文件读取的数据，该数据将被存储在buffer指向的内存区域中。
  1. 若要用fopen函数打开一个新的二进制文件，该文件既要能读也要能写，则文件方式字符串应是( )。

A)"ab+" B)"wb+" C)"rb+" D)"ab"

  • b
  1. 设有以下结构体类型

struct st

{ char name[8];

int num;

float s[4];

} student[50];

且结构体数组student中的元素都已赋值，若要将这些元素值写到文件fp中，以下不正确的形式是( )。

A) fwrite(student, sizeof(struct st), 50, fp);

B) fwrite(student, 50*sizeof(struct st), 1, fp);

C) fwrite(student, 25*sizeof(struct st), 25, fp);

D) for (i=0; i<50; i++)

fwrite(student, sizeof(struct st), 1, fp);

  • c
由于fwrite函数的第二个参数sizeof(struct st)表示一次要写入的字节数，而第三个参数25表示要写入的元素个数，所以
它们的乘积就是要写入的总字节数，但是实际上student数组中只有50个元素，不足25个，所以如果按照选项C的形式调
用fwrite函数，将会写入超出数组student的内存，造成不确定的错误，因此选项C是不正确的
  1. 正常执行文件关闭操作时，fclose函数的返回值是( )。

A)-1 B)TRUE C)0 D)1

  • c
  1. 若以“a+　”方式打开一个已存在的文件，则以下叙述正确的是( )。

A)文件打开时，原有文件内容不被删除，位置指针移到文件末尾，可作添加和读操作

B)文件打开时，原有文件内容不被删除，位置指针移到文件开头，可作重写和读操作

C)文件打开时，原有文件内容删除，只可作写操作

D)以上各种说法皆不正确

  • a
若以"a+"方式打开一个已存在的文件，它将被打开为追加模式，以便进行读写操作。在此模式下，每次的写操作都会在文件的末尾追加内容，并不会替换文件原来的内容。

如果文件不存在，则该函数将创建一个新文件。在这种情况下，新创建的文件将打开为可读写模式，并可以对其进行读写操作。

该方式对于需要在文件的末尾添加内容的场景非常适用。例如，在日志文件中记录数据或者在已存在的文件上继续写入数据等。
  1. 设fp是指向某个文件的指针，且已读到文件末尾，则库函数feof(fp)的返回值是( )。

A)EOF B) -1 C)非零值 D)NULL

  • c
  1. 函数ftell(fp)的作用是( )。

A)得到流式文件中的当前位置

B)移动流式文件的位置指针

C)初始化流式文件的位置指针

D)以上答案均正确

ftell 函数用于获取当前读写指针在文件内的位置。使用方法如下：

c

#include <stdio.h>

int main()
{
    FILE *fp;
    long int pos;

    fp = fopen("file.txt", "r");

    if (fp == NULL)
    {
        printf("Error opening file!\n");
        return 1;
    }

    /* Move the read/write pointer to the end of the file */
    fseek(fp, 0L, SEEK_END);

    /* Get the current position of the pointer */
    pos = ftell(fp);

    printf("Current position of the pointer in the file: %ld\n", pos);

    fclose(fp);

    return 0;
}

上面的代码打开了名为 "file.txt" 的文件，并移动读写指针到文件的末尾，然后调用 ftell 函数获取读写指针在文件内
的位置，最后在控制台输出该位置。
  1. 利用fseek函数可实现的操作是( )。

A)改变文件的位置指针

B)文件的顺序读写

C)文件的随机读写

D)以上答案均正确

  • a
  1. fseek函数的正确调用形式是( )。

A)fseek(文件类型指针, 超始点, 位移量);

B)fseek(fp, 位移量, 起始点);

C)fseek(位移量, 起始点, fp);

D)fseek(起始点, 位移量, 文件类型指针);

  • b
  1. fwrite函数的一般调用形式是( )。

A) fwrite(buffer, count, size, fp);

B) fwrite(fp, size, count, buffer);

C) fwrite(fp ,count, size, buffer);

D) fwrite(buffer, size, count, fp);

  • d
  1. 标准库函数fgets(p1, k, f1)的功能是( )。

A)从f1所指的文件中读取长度为k的字符串存放指针p1所指的内存

B)从f1所指的文件中读取长度为不超过k-1的字符串存入指针p1所指的内存

C)从f1所指的文件中读取k个字符串存入指针p1所指的内存

D)从f1所指的文件中读取长度为k-1的字符串存入指针p1所指的内存

  • d
  1. 若要指定打开c盘上子目录myfile下的二进制文件test.bin，在调用函数fopen时，第一个参数的正确格式是( )。

A) "c:myfile\test.bin"

B) "c:\myfile\test.bin"

C) "c:\myfile\test.bin"

D) "c:\myfile\test.bin"

  • c
  1. 阅读以下程序及对程序功能的描述，其中正确的描述是( )。

#include

int main( )

{ FILE in, out;

char ch, infile[10], outfile[10];

printf("Enter the infile name:\n");

scanf("%s", infile);

printf("Enter the outfile name:\n");

scanf("%s", outfile);

if ((in = fopen(infile, "r")) == NULL)

{ printf("Cannot open infile!\n");

return 0;

}

if ((out = fopen(outfile, "w"))== NULL)

{ printf("Cannot open outfile!\n");

return 0;

}

while (!feof(in)) fputc(fgetc(in), out);

fclose(in);

fclose(out);

}

A)程序的功能是：将磁盘文件的信息在屏幕上显示

B)程序的功能是：将两个磁盘文件合二为一

C)程序的功能是：将一个磁盘文件复制到另一个磁盘文件

D)程序的功能是：将两个磁盘文件合并，且在屏幕上输出

  • c
  1. 文件的读函数是从输入文件中读取信息，并存放在内存中。
  • 对
  1. 不能用"r"方式打开一个并不存在的文本文件。
  • 对
  1. 以“a”方式打开一个文件时，文件位置指针指向文件头。
  • 错
  1. 将当前目录下的jsgc01.txt文件内容读取出来并显示在屏幕上。
\#include <stdio.h>
\#include <stdlib.h>

int main(void)
{
 FILE *fp;
 int ch;

 /*********Found************/
 fp = fopen("jsgc01.txt", "w");
    /*********End************/

 if (NULL == fp)
 { 
 printf( "Cannot open file!\n") ;
 exit(1) ;   
 }

 ch = fgetc(fp);
 /*********Found************/
 while (ch)
    /*********End************/

 {
 putchar(ch);
 ch = fgetc(fp);
 }
 printf("\n");

 fclose(fp);
 return 0;
}
  • 第一处: fp = fopen("jsgc01.txt", "r");
  • 第二处: while (ch!=EOF)
  1. 从键盘输入数量不限的字符，以#作为结束符(#不存入后面要求的文件中)，存入当前目录下的文件文件Exam.txt中(如果文件不存在则创建，若存在则先清空其内容)。
\#include <stdio.h>
\#include <stdlib.h>

int main(void)
{
 FILE *fp;
 char ch;

 /*********Found************/
 if ((fp = fopen("Exam.txt", "r")) == NULL) 
    /*********End************/

 {
 printf("can not open this file\n");
 exit(0);
 }

 /*********Found************/
 for( ; ch=getchar() == '#'; )
    /*********End************/

 {
 fputc(ch, fp);
 }

 fclose(fp);
 return 0;
}

文件程序

  1. 有两个文本文件lb8103a.txt和lb8103b.txt。键盘输入需要读的文件名，然后从该文件中读出前n（<=26）个字符。

图1中的lb8103a.txt和3，图2中的lb8103b.txt和8，图3中的lb8103.txt和3是从键盘输入的。未解决,只有85分

img

img

img

#include <stdio.h>

int main(void)
{
char str[20],ch;
int b;
FILE *fp;
int n;
printf("Input filename:");
    scanf("%s", str);
    printf("Input n:");
    scanf("%d", &n);

fp=fopen(str,"r");
if(fp==NULL)
{
printf("Open Error!\n");
        return 0;
}
printf("Output:\n");
for (int i = 0; i < n; i++)
    {
        ch=fgetc(fp);
putchar(ch);
    }
fclose(fp);

    return 0;
}
  1. 按要求写前n个数据到文本文件lb8204.txt，然后从该文件读数据并显示。

写入的数据是1到1000中是7的倍数或者是数字中含7的数（如：37，71，72等）。

图中80是键盘输入的，每个数占4个宽度，每10个数换一行。

注：只允许在/\start\/和/\end\/之间添加代码。

img

#include <stdio.h>
#include <stdlib.h>

void save(int n);
void out(void);

int main(void)
{
    int n;
    printf("Input n:");
    scanf("%d", &n);
    save(n);
    out();
    return 0;
}

void save(int n)
{
    /******start******/

    /******end******/
}

void out(void)
{
    char str[48];
    char *pch = NULL;
    FILE *fp;
    fp = fopen("lb8204.txt", "r");
    if (fp == NULL)
    {
        exit(0);
    }
    printf("Output:\n");
    while (!feof(fp))
    {
        pch = fgets(str, 48, fp);
        if (pch == NULL)
        {
            break;
        }
        printf("%s", str);
    }
    printf("\n");
    fclose(fp);
}
#include <stdio.h>
#include <stdlib.h>

void save(int n);
void out(void);

int main(void)
{
    int n;
    printf("Input n:");
    scanf("%d", &n);
    save(n);
    out();
    return 0;
}

void save(int n)
{
    int con=0;
    FILE *fp;
    fp=fopen("lb8204.txt","w");
    /******start******/
for(int i=1;i<=1000;i++)
{
    if(con==n)break;

    if(i%7==0||i%10!=7||(i-i%100)!=7||(i-i%10)/10%10!=7)
    {
        fprintf(fp,"%4d",i);
        con++;

    }
    if(i%10==0)fprintf(fp,"\n");
}
fclose(fp);
    /******end******/
}

void out(void)
{
    char str[48];
    char *pch = NULL;
    FILE *fp;
    fp = fopen("lb8204.txt", "r");
    if (fp == NULL)
    {
        exit(0);
    }
    printf("Output:\n");
    while (!feof(fp))
    {
        pch = fgets(str, 48, fp);
        if (pch == NULL)
        {
            break;
        }
        printf("%s", str);
    }
    printf("\n");
    fclose(fp);
}
  1. 编写一程序实现以下功能 有一存储很多商品数据(每件商品的属性先后包括：品名、规格、数量、单价，编程时相应的数据类型分别定义为字符串char(20)、字符串char(12)、int、float)的二进制文件sp.dat(即未作任何格式转换而直接使用fwrite将商品属性写入文件)，从键盘输入某种商品的品名，要求在文件中查找有无相应品名商品(可能有多条记录或没有)，若有则在屏幕上显示出相应的商品的品名、规格、数量、单价(显示时，品名、规格、数量、单价之间使用逗号(,)作分隔)，若无则显示没有相应品名的商品。 编程可用素材：printf("Please input shang pin pin ming:")...、printf("Output:\ncha zhao qing kuang:\n")...、printf("mei you shang pin :...。 程序的运行效果应类似地如图1和图2所示，图1中的Please input shang pin pin ming:xuebi中的xuebi和图2中的Please input shang pin pin ming:kele中的kele是从键盘输入的内容。

img

img

#include <stdio.h>
#include <string.h>

struct good
{
    char name[20];
    char type[12];
    int number;
    float price;
};

int main(void)
{
    int i = 0, n, flag;
    char str[20];
    struct good goods[100];

FILE *fp;

fp=fopen("sp.dat","rb");
while(!feof(fp))
{
    fread(&goods[i],sizeof(struct good),1,fp);
    i++;
}

    n = i;
    flag = 0;
    printf("Please input shang pin pin ming:");
    scanf("%s", str);
    printf("Output:\ncha zhao qing kuang:\n");
    for (i = 0; i < n; i++)
    {
        if (strcmp(goods[i].name, str)==0)
        {
            printf("%s,%s,%d,%.2f\n", goods[i].name, goods[i].type,
                goods[i].number, goods[i].price);
            flag = 1;
        }
    }
    if (flag == 0)
    {
        printf("mei you shang pin %s\n", str);
    }
    return 0;
}
  1. 有二进制文件lb8104.dat存放了50个整数。键盘输入start和end，计算从第start个到第end个数之和（含start和end）。

图中10和20是键盘输入的。（注：如输入1和1，输出34，暂不考虑其他异常）

img

#include <stdio.h>
#include <string.h>

int main(void)
{
        printf("Input start and end:");
    int s,e;
    int a[50],o=0;
    scanf("%d %d",&s,&e);
        printf("Output:\n");
    FILE *fp;

    fp=fopen("lb8104.dat","rb");
        if (fp == NULL)
        {
            printf("File Open Error!\n");
            return 0;
        }
    for(int i=s-1;i<=e-1;i++)
    {
        fread(&a,sizeof(int),50,fp);
        o=o+a[i];

    }
    printf("%d",o);
    return 0;
}
  1. 有文本文件lb8102.txt存储类点阵数字字库（每个数字8行5列）。从键盘输入n（0-9），输出该数字。

图中6是键盘输入的。未解决

img

#include <stdio.h>

int main(void)
{
    int i, n;
    char str[120];
    FILE *fp;
    fp = fopen("lb8102.txt", "r");

    printf("Input n:");
    scanf("%d", &n);
    printf("Output:\n");

    for (i = 0; i < n*8;i++)
    {
        fgets(str, 11, fp);
    }
    for (i = 0; i < 8; i++)
    {
        fgets(str, 7, fp);
        printf("%s", str);
    }
    return 0;
}
  1. 程序功能：将斐波拉契数列的前n项用二进制方式写入自命名文件中，然后从该文件中读取这n个数输出。

注：a1=1, a2=1, a3=2, ......, an=an-1+an-2，只允许在/\start\/和/\end\/之间添加代码。

图中te.dat和10是键盘输入。

img

#include <stdio.h>
#include <stdlib.h>

void save(char str[20], int n);
void prnt(char str[20], int n);

int main()
{
    int n;
    char str[20];

    printf("Input filename:");
    scanf("%s", str);
    printf("Input n:");
    scanf("%d", &n);
    save(str, n);
    prnt(str, n);
    return 0;
}

void save(char str[20], int n)
{
    /******start******/

    /******end******/
}
void prnt(char str[20], int n)
{
    int i, te;
    FILE *fp;

    fp = fopen(str, "rb");
    if (fp == NULL)
    {
        exit(0);
    }
    printf("Output:\n");
    for (i = 0; i < n; i++)
    {
        fread(&te, sizeof(int), 1, fp);
        printf("%d ", te);
    }
    printf("\n");
    fclose(fp);
}
    int i, f1 = 1, f2 = 1;
    FILE *fp;

    fp = fopen(str, "wb");
    fwrite(&f1, sizeof(int), 1, fp);
    fwrite(&f2, sizeof(int), 1, fp);
    for (i = 0; i < n/2; i++)
    {
        f1 = f1+f2;
        f2 = f1+f2;
        fwrite(&f1, sizeof(int), 1, fp);
        fwrite(&f2, sizeof(int), 1, fp);
    }
    fclose(fp);
  1. 文本文件lb8101.txt中存放了50个整数。从键盘输入n值，求该文件中后n个数的和。

图中13是键盘输入的。

img

#include <stdio.h>
#include <stdlib.h>

int main()
{
int n,m=0;
int t[100];
printf("Input n:");
scanf("%d",&n);
FILE *fp;
fp=fopen("lb8101.txt","r");
for(int i=1;i<=10;i++)
{
    for(int q=1;q<=5;q++)
    {
        fscanf(fp,"%d",&t[(i-1)*5+q]);
    }
}
for(int i=50;i>50-n;i--)
{
    m=m+t[i];
}
    printf("Output:\n%d",m);
    return 0;
}
  1. 编写一程序D1402.C实现以下功能未解决 程序运行时，先从键盘输入一个文本文件的文件名(约定：字符数≤127字节，可含路径)和一个字符串(约定：字符数≤20字节，其中不含空格、TAB等，后面称之为Str)，再在屏幕上显示该文件的内容。要求显示完内容后，在屏幕上输出文件的行数(行之间以’\n’为分隔、每行的长度不定但均≤200个字节)、字符串Str在文件中第1次出现的行号和最后一次出现的行号(查找时不区分大小写、不跨行查找，若未找到，则行号显示为-1)。注意，行的编号从1开始计。 　　下载程序运行时测试用的文件**Test.txt**。编程可用素材：printf("input the file's name and the string: ")...、printf("\nfile open error!")...、printf("------------------------File content:----------------------\n")...、printf("\n------------------------File summary:----------------------\n")...、printf("... lines, first line: ..., last line: ...\n"...。 　　程序的运行效果应类似地如图所示，图中的“input the file's name and the string: test.txt value”中的“test.txt value”是从键盘输入的内容(“test.txt”是文件名，“value”是需查找的字符串)。图中的“10 lines, first line: 6, last line: 9”表示文件一共有10行，字符串“value”在文件中第一次出现的行号为6、最后一次出现的行号为9。不存在的字符串，出现行号为-1。
届ける言葉を今は育ててる
最后更新于 2024-02-07
啥也没有呀