嵌入式linux笔试题重点概念知识梳理

1、关键字static的作用

在C语言中，关键字static有三个明显的作用：

1)在函数体内，一个被声明为静态的变量在这一函数被调用过程中维持其值不变（该变量存放在静态变量区）。

2)在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。

3)在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

在类中，

4）在类中的static成员变量意味着它为该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见；

5）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。

2、程序运行时的内存分配

一个由C/C++编译的程序占用的内存分为以下几个部分

1、栈区（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区（heap）—一般由程序员分配释放（malloc/free、new/delete），若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式类似于链表。

3、全局区（静态区）（static）—全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后由系统释放。

4、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放

5、程序代码区—存放函数体的二进制代码。

3、关键字const的含义

const int a;  //a不能更改

int const a; //同上

const int *a; //*a不可更改，a这个地址（指针）可以更改

int * const a; //a这个指针不可更改，*a可以更改

int const *  const  a; //a和*a都不可更改

总之，const后面的东西不能修改。

4、关键字volatile含义

防止编译器优化，编译器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。

5、野指针

“野指针”不是NULL指针，是指向“垃圾”内存（不可用内存）的指针。

野指针的成因主要有三种：

一、指针变量没有被初始化。指针变量在定义的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。

二、指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。

三、指针操作超越了变量的作用范围。比如不要返回指向栈内存的指针或引用，因为栈内存在函数结束时会被释放。

6、sizeof和strlen区别

一、sizeof

sizeof(...)是运算符，在头文件中typedef为unsigned int，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。

二、strlen

strlen(...)是函数，要在运行时才能计算。参数必须是字符型指针（char*）。当数组名作为参数传入时，实际上数组就退化成指针了。它的功能是：返回字符串的长度。该字符串可能是自己定义的，也可能是内存中随机的，该函数实际完成的功能是从代表该字符串的第一个地址开始遍历，直到遇到结束符NULL。返回的长度大小不包括NULL。

总之，sizeof返回定义arr数组时，编译器为其分配的数组空间大小，不关心里面存了多少数据。strlen只关心存储的数据内容，不关心空间的大小和类型。其中\0不计入strlen计数中去。

具体题目：

2.1 在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。

int*ptr;

ptr =(int *)0x67a9;

*ptr =0xaa55;

或者：    #define  __REG(ptr)      *((int * const) str)

__REG(0x67a9) = 0xaa55;

2.2 写出strcpy,strlen函数源码的实现。

char * strcpy( char*strDest, const char *strSrc )

{

assert( (strDest !=NULL) && (strSrc != NULL) );

char *address =strDest;

while( (*strDest++= * strSrc++) !=‘\0’ );      //while(*dest++ = *src++); 注意分号

return address;

}

 

int strlen( const char *str ) //输入参数const

{

assert(strt != NULL); //断言字符串地址非0

int len;

while( (*str++) !='\0' )

{

len++;

}

return  len;

}

char *strcat(char *ch,char *ch1)
{
if(ch == NULL || ch1 == NULL)
return NULL;
char *p,*q;
p = ch;
q = ch1;
while(*p != '\0')
p++;
while(*q != '\0')
{
*p = *q;
p++;
q++;
}
*p = '\0';
return ch;
}

void *  memcpy (void * dst,const void * src,size_t count )

{

        void * ret = dst;

             if((dst == NULL)||(src == NULL)||(count== 0))

                    return NULL;

        while (count--) {

                *(char *)dst = *(char *)src;

                dst = (char *)dst + 1;

                src = (char *)src + 1;

        }

        return(ret);

}

2、大端模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中；

  小端模式，是指数据的低位保存在内存的低地址中，而数据的高位，保存在内存的高地址中。

网络传输一般用大端，本地存储一般用小端。

求是大端还是小端的程序。

1. #include<stdio.h>
2. int main()
   
3. {
   
4.     int x = 1;
   
5.     char *p = (char *)&x;
   
6. 
   
7.     if(*p)
   
8.     {
   
9.         printf("little\n");
   
10.     }
    
11.     else
    
12.     {
    
13.         printf("large\n");
    
14.     }
    
15.     return 0;
    
16. }

2.4用变量a 给出下面的定义

a) 一个整型数（An integer）

b)一个指向整型数的指针（A pointer to an integer）

c)一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to anintege）r

d)一个有10 个整型数的数组（An array of 10 integers）

e) 一个有10 个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers tointegers）

f) 一个指向有10 个整型数数组的指针（A pointer to an array of 10integers）

g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer asan argument

and returns an integer）

h)一个有10 个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（An array of ten pointers tofunctions t

hat take an integer argument and return aninteger ）

答案是：

a) int a; // An integer

b) int *a; // A pointer to an integer

c) int **a; // A pointer to a pointer to aninteger

d) int a[10]; // An array of 10 integers

e) int *a[10]; // An array of 10 pointers to integers

f) int (*a)[10]; // A pointer to an array of 10integers

g) int (*a)(int); // A pointer to a function athat takes an integer argument and returns an integer

h) int (*a[10])(int); // An array of 10 pointersto functions that take an integer argument and return an integer

2.5 位操作

嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a的bit 3。在以上两个操作中，要保持其它位不变。

#define BIT3 (0x1 << 3)

static int a;

void set_bit3(void) {

a |= BIT3;

}

void clear_bit3(void) {

a&= ~BIT3;

}#define BIT3 (0x1 << 3)

staticint a;

void set_bit3(void) {

a |= BIT3;

}

void clear_bit3(void) {

a&= ~BIT3;

}

 

2.6 与“零值”比较

分别给出BOOL，int，float，指针变量与“零值”比较的 if语句（假设变量名为var）

解答：

BOOL 型变量：if(!var)

int型变量：if(var==0)

float 型变量：

const floatEPSINON = 0.00001;

if ((x >= -EPSINON) && (x <= EPSINON)

指针变量：if(var==NULL)

 

2.8 malloc分配的是物理地址还是虚拟地址

物理地址

 

2.9 不是使用变量，调换两个变量的值

int a=10,b=20;

a=a+b;

b=a-b;

a=a-b;

结果：a=20;b=10;

或者：

a = a ^ b;

b = a ^ b;

a = a ^ b;

 

2.    冒泡排序

#define LEN 8

int a[LEN]={5,4,3,2,1,7,6,0};

intbubble_new_sort(void)

{

      int i=0; int j = 0;     int k = 8;      int flage = 1; int tmp  =0;

    for(i=1;(i<k)&&(flage == 1);i++){

             flage = 0;

             for(j=0;j<k-i;j++){

                 if(a[j]>a[j+1]){

                      tmp =a[j];

                      a[j] = a[j+1];

                      a[j+1] = tmp;

                      flage=1 ;

                    }

             }

       printf("i = %d : %d,%d,%d,%d,%d,%d,%d,%d\n",i,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);

}

      printf("%d,%d,%d,%d,%d,%d,%d,%d\n",a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);

    return 0;

}

3.    进程和线程的区别

进程是表示资源分配的基本单位，又是调度运行的基本单位。

线程是进程中执行运算的最小单位，亦即执行处理机调度的基本单位。

 

5.  请问C++的类和C 里面的struct 有什么区别？

c++中的类具有成员保护功能，并且具有继承，多态这类oop特点，而c 里的struct 没有

7.    二分查找思想

int binary_search(int* a, int len, int goal)

{

    int low = 0;

    int high = len - 1;

    while(low <= high)

    {

        int middle = (low +high)/2;

        if(a[middle] == goal)

            return middle;  //在左半边

        else if(a[middle] >goal)

            high = middle - 1;//在右半边

        else

            low = middle + 1;

    }

    return -1; //没找到

}