首页 > 代码库 > 一份笔试题
一份笔试题
笔试题目
一、选择题
二、 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]={1，3，5，7，9，11，13，15，17，19，21，23｝; int (*p)[4]，i=2，j=1; p=a; printf(″%d\n″，*(*(p+i)+j)); } A.9 B.11 C.17 D.19
6:在软件生命周期中，下列哪个说法是不准确的?( C )
A.软件生命周期分为计划、开发和运行三个阶段 B.在计划阶段要进行问题确认和需求分析 C.在开发后期才能进行编写代码和软件测试 D.在运行阶段主要是进行软件维护
7：下列语句定义整型指针p1、p2，( 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内核从中如果板子的ID和linux中相应的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
一份笔试题