首页 > 代码库 > 一份笔试题

一份笔试题

笔试题目                                           

一、选择题

二、 1:main()   { int x=1,y=1;    y=x--      printf( %d,%d\n ,x,y);  }运行结果为(  B)   A.0 0                            B.0 1  C.1 0                             D.1 1   

 2:某文件中定义的静态全局变量(或称静态外部变量)其作用域是( B )  

A.只限某个函数                B.本文件   C.跨文件                     D.不限制作用域  

 3:int a[10],*p=a 则对数组元素的正确引用是(C  )  

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

4:C语言中,系统自动打开的文件是(  A)   A.二进制文件                     B.随机文件  C.非缓冲文件                     D.设备文件   

5:下列程序的运行结果是( D )   

 main( )   { int a[][4]={1357911131517192123;   int (*p)[4]i=2j=1;   p=a;    printf(%d\n″,*(*(p+i)+j));  }   A.9      B.11        C.17         D.19   

 6:在软件生命周期中,下列哪个说法是不准确的?( C )   

 

A.软件生命周期分为计划、开发和运行三个阶段  B.在计划阶段要进行问题确认和需求分析  C.在开发后期才能进行编写代码和软件测试  D.在运行阶段主要是进行软件维护    

7:下列语句定义整型指针p1p2( B )  是正确的。  A.int p1,p2;                    B.int *p1,*p2;  C.int *p1,p2;                   D.int **p1,p2;

B. 8:下列程序的运行结果是(  B)  main()  {    int  a[5] = {1,2,3,4,5};   int *ptr =  (int*)(&a+1);     printf("%d %d" , *(a+1), *(ptr-1) );  }  A. 2  2                                  B. 2  1  C.2  5                                  D.以上均不是

C.二、简答题  

D.8、下面的程序或程序段存在一个错误或不妥处请在其下划一条线,并将改正的内容写到每小题后的空白处  

main()   {

char c1,c2;    

c1=‘9‘;

   c2=‘10‘;   

  printf(cl=%c,c2=%c\n,c1,c2);  

}    

 答:char cl,c2;  

 printf(c1=%c,c2=%c\n,c1,c2);

改: char c1,*c2;

       c2="10";

       printf(cl=%c,c2=%s\n,c1,c2);  

9、下面的代码输出是什么,为什么? void foo(void) {  unsigned int a = 6; int b = -20;  (a+b > 6) ? puts("> 6") : puts("<= 6"); }  

   输出:>6  因为:当unsigned int类型和int类型相加int的类型会被转变成unsigned int,那么b=10...10100 ,所以:a+b>6

   10、中断是嵌入式系统中重要的组成部分,这导致了很多编译开发商提供一种扩展 ―让标准 C支持中断。具代表事实是,产生了一个新的关键字__interrupt,下面的代码就使用了 __interrupt关键字去定义了一个中断服务子程序 (ISR),请评论一下这段代码,找出错误并改正.  

__interrupt double compute_area (double radius)

 {  

double area = PI * radius * radius;

printf("\nArea = %f", area);

return area;

 }    

答:__interrupt double compute_area (double radius)

   应把double去掉和把double radius改成void 因为中断处理函数不能传参和返回值所以自然return 也要去掉。

 

 

 

  

三、内核驱动题

 11、请简述arm linux内核启动流程。

  答:首先IROM先把一段一段裸机程序复制到SRAM中启动进行初步初始化arm在通过里面的复制剩余代码至DRAM进行下一部分的初始化和引导启动linux内核从中如果板子的IDlinux中相应的ID不能匹配的话linux将无法启动。    

  12、驱动里面为什么要有并发、互斥的控制?如何实现?举例说明。

并发:可分两种一种宏观上并发微观上串行,一般出现在单核CPU中,这种采用某种算法使得个进程轮流占用CPU,当时间片用完即退下让下一个进程占用CPU。别一种是宏观上和微观上都是并发的这种一般在多核CPU中,是真正上并发,并发本质就是提高CPU的效率,使得CPU不会因为一个进程阻塞而不工作,也不会因为一个进程运行时间长而使得其他进程等待太久。

互斥:互斥是为了某个变量,某个函数因为多人一起操作而使结果不朝着我们想要的方向走。

如系统文件中有个txt文件多人读可以,但是如果多人一起写这个txt的话那么这个txt就很难看懂了,如果这里这里设置一个互斥量使一次只有一个人可写那么txt就不会混乱了。     

  13、请简述linux内核终端处理分成上半部分和下半部分的原因,为何要分?如何实现?

   linux内核终端处理分上下部分的原因:首先分上下部是的真正要屏蔽中断时间不会太长而使linux重启。而且把不紧急的代码放下下部分,可以使CPU更多时间去相应其他终端,也可以提高CPU的效率。

  四、编程实现题  

14、设计并实现一个在linux平台下简单的内存FIFO字符设备驱动,并简述该驱动的验证方法。

#include <linux/init.h>

#include <linux/module.h>

#include <linux/fs.h>

#include <linux/cdev.h>

#include <linux/device.h>

#include <linux/stat.h>

#include <linux/slab.h>

#include <linux/kdev_t.h>

#include <linux/moduleparam.h>

#include <linux/sched.h>

#include <linux/platform_device.h>

#include <linux/uaccess.h>

 

 

MODULE_LICENSE("GPL");

 

#define FIFO_MAJOR 0

#define FIFO_MINOR 0

#define DEV_NUM 1

#define FIRSTPRI_NUM 0

#define DATA_NUM 100

#define DRI_NAME "fifo_dev"

 

unsigned int fifo_major = FIFO_MAJOR,fifo_minor = FIFO_MINOR;

 

dev_t fdev_t;

 

 

 

module_param(fifo_major,int,S_IRUSR);

module_param(fifo_minor,int,S_IRUSR);

 

struct fifo_dev

{

    struct cdev tcdev;

int data[DATA_NUM];

int pri,tail;

};

 

static struct class *my_class;

 

static struct fifo_dev *fifo_devs;

 

static struct device *my_devices;

 

static int fifo_open(struct inode * node,struct file * filep)

{

     int i=0;

 struct fifo_dev *fifodev = NULL;

 

 printk(KERN_INFO"Fifo_dev:Hello come to fifo_open");

 

 fifodev = container_of(node->i_cdev,struct fifo_dev,tcdev);

 

filep->private_data = http://www.mamicode.com/fifodev;

 

return 0;

 

}

 

static ssize_t fifo_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)

{

      int i=0,j=0;

  int tbuff[DATA_NUM];

  struct fifo_dev *fifodev = NULL;

 

      printk(KERN_INFO"Fifo_dev:Hello come to fifo_open");

 

  fifodev = file->private_data;

 

  if(fifodev->pri == fifodev->tail)

  {

       printk(KERN_NOTICE"Fifo_dev:No data to read");

 count = 0;

return count;

  }

     

i=fifodev->pri - fifodev->tail;

if(i<count)

count = i;

for(;j<=count;j++)

        tbuff[j]=fifodev->data[fifodev->tail+j];


 

    

copy_to_user(buf,tbuff,count);

 

    fifodev->tail+=count;

 

return count;

  

}

 

static ssize_t fifo_write(struct file * file,const char * buf,size_t n,loff_t * ppos)

{

      int i=0,j=0,k=0,q=0;

  int tbuff[DATA_NUM];

  struct fifo_dev *fifodev = NULL;

 

      printk(KERN_INFO"Fifo_dev:Hello come to fifo_write");

 

  fifodev = file->private_data;

 

  j=DATA_NUM-n;

 

      if((fifodev->pri) >= j)

  {

       if((fifodev->tail) >= n)

       {

            k=fifodev->tail-n;

 

 if(((fifodev->pri )- (fifodev->tail)) > k)

 q=k;

 else

 q= fifodev->pri - fifodev->tail;

 

         for(;i<q;i++)

      {

      fifodev->data[k+i]=fifodev->data[fifodev->tail+i];

       }

 

         }

     else{

 q=n;

k=0;

 for(;i<q;i++)

      {

      fifodev->data[k+i]=fifodev->data[fifodev->tail+i];

       }

     }

 

              fifodev->tail=k;

  fifodev->pri = q + fifodev->tail;

 

      }

 

     copy_from_user(tbuff,buf,n);

 

 for(;j<=n;j++)

        fifodev->data[fifodev->pri+j]=tbuff[j];

 fifodev->pri +=n;

 

 return n;

  

}

 

static struct file_operations fifo_cdev=

{

    .owner = THIS_MODULE,

    .read  = fifo_read,

.open  = fifo_open,

.write = fifo_write,

};

 

static int fifo_probe (struct platform_device *dev)

{

    int ret;

 

if(fifo_major = 0)

{

      ret = alloc_chrdev_region(fdev_t,FIFO_MINOR,DEV_NUM,DRI_NAME);

}

else

{

      ret = register_chrdev_region(fdev_t,DEV_NUM,DRI_NAME);

}

    if(IS_ERR(ret))

    {

           printk(KERN_ERR"Fifo_dev:Failed for chrdev_region");

 

   return -ENOANO;

    }


      printk(KERN_INFO"Fifo_dev:Success for chrdev_region");

 

  fifo_devs = kmalloc(sizeof(struct fifo_dev)*DEV_NUM,GFP_KERNEL);

  if(fifo_devs ==NULL)

  {

       printk(KERN_ERR"Fifo_dev:Failed for kmalloc");

 

 goto failed_kmalloc;

  }

  printk(KERN_ERR"Fifo_dev:Succwss for kmalloc");

 

  memset(fifo_devs,sizeof(struct fifo_dev)*DEV_NUM,0);

 

  my_class = class_create(THIS_MODULE,DRI_NAME);

  if(my_class ==NULL)

  {

   printk(KERN_ERR"Fifo_dev:Failed for my_class");

  

   goto failed_my_class;

  }

printk(KERN_ERR"Fifo_dev:Succwss for my_class");

 

 

 

  my_devices=device_create(my_class,NULL,fdev_t,NULL,DRI_NAME);

 

      if(my_devices ==NULL)

  {

   printk(KERN_ERR"Fifo_dev:Failed for my_devices");

  

   goto failed_my_devices;

  }

  printk(KERN_ERR"Fifo_dev:Succwss for my_devices");

 

  cdev_init(&(fifo_devs->tcdev),&fifo_cdev);

 

  ret=cdev_add(&(fifo_devs->tcdev),fdev_t,1);

  if(ret<0)

  {

       printk(KERN_ERR"Fifo_dev:Succwss for cdev_add");

 goto failed_cdev_add;

  }

  printk(KERN_ERR"Fifo_dev:Succwss for cdev_add");

 

  fifo_devs->pri = FIRSTPRI_NUM;

  fifo_devs->tail= FIRSTPRI_NUM;

 

  return 0;

 

failed_cdev_add:

 

device_del(my_devices);

 

failed_my_devices:

 

class_destroy(my_class);

 

failed_my_class:

 

kfree(fifo_devs);

  

failed_kmalloc:

 

unregister_chrdev_region(fdev_t,DEV_NUM);

 

return -ENOANO;

 

}

 

static int fifo_resume(struct platform_device *dev)

{

        cdev_del(&(fifo_devs->tcdev));

  

device_del(my_devices);


class_destroy(my_class);


kfree(fifo_devs);


unregister_chrdev_region(fdev_t,DEV_NUM);


return 0;

 

}

 

struct platform_driver fifo_plat_dri ={

 

.probe  = fifo_probe,

.resume = fifo_resume,

.driver = {

.name = DRI_NAME,

.owner = THIS_MODULE,

},

 

 

};

 

static int __init fifo_inits(void)

{

     int ret;

  ret = platform_driver_register(&fifo_plat_dri);

 

return 0;

}

static void __exit fifo_exits(void)

{

    platform_driver_unregister(&fifo_plat_dri);

}

module_init(fifo_inits);

module_exit(fifo_exits);

 

 

 

测试:read.c

 

#include <stdio.h>

 

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/ioctl.h>

 

int main(int argc , char **argv){

int fd,count,i;

        int buf[100];

char *lednode = "/dev/fifo_dev";

 

/*O_RDWR只读打开,O_NDELAY非阻塞方式*/

if((fd = open(lednode,O_RDWR|O_NDELAY))<0){

printf("APP open %s failed!\n",lednode);

}

else{

printf("APP open %s success!\n",lednode);

                

                count = argv[1];

read(fd, buf, count);

printf("read num :\n");

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

               {

                     printf("%d  ",buf[i]);

                }

               printf("\n");

}


close(fd);

}

 

 

 

write.c

 

#include <stdio.h>

 

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/ioctl.h>

 

int main(int argc , char **argv){

int fd,count,i;

        int buf[100];

char *lednode = "/dev/fifo_dev";

 

/*O_RDWR只读打开,O_NDELAY非阻塞方式*/

if((fd = open(lednode,O_RDWR|O_NDELAY))<0){

printf("APP open %s failed!\n",lednode);

}

else{

printf("APP open %s success!\n",lednode);

                

                count = argc;

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

                {

                      buf[i-1]=argv[i];

                 }

write(fd, buf,count);


}


close(fd);

}


本文出自 “毛散人” 博客,请务必保留此出处http://songmao.blog.51cto.com/11700139/1882180

一份笔试题