2012联发科校园招聘手机软件部门试题详解

2012联发科校园招聘 手机软件部门笔试&第一轮面试 试题详解

 

选择题我有印象的：

1.int p = (short)0x8000,问打印p是多少？-32678

将16 位short扩展为   32位int ，把符号位一起扩展 oxffff8000，最高位为 1是负数，取反加1 得到-32768

 

2.##的使用(连接)：

define call(x,y) x##y

3.char* str = "hello"

   str = "pri"

  prinf("%s",str);有什么问题？直接崩溃，char *s = "hello",hello存在了常量存储区，只能读不能修改

指针存储的是全局变量，是在静态的存储区域内的，是不能随便修改的，

如果是数组，那么是存储在局部变量的，是可以修改的。

4.大端小端的概念

char c = 'abc'

在大段和小段下，打印c的结果是什么？

  大端情况为 数据的高字节是在存储空间的低位 ，数据的低字节是在存储空间的高位

相反，小端情况 是数据的高字节在存储空间的高位 ，数据的低字节在存储空间低位

打印一般是按先打印存储空间的低位，然后打印高位：

在大端情况下为： abc

小端情况为：cba

简答题：

（1）动态内存分配

   为了防止内存在编译是造成浪费或者内存不足，需要在运行的时候进行动态内存分配，根据数据大小动态分配内存，new delete , malloc free 在动态申请后 ，使用完进行释放内存。对一个动态申请的内存不能释放两次。

（2）extern c的用法

   extern C 一个是用来修饰函数和全局变量的，声明一个函数或者变量，但是并没有定义它们，而且它们只能被定义一次。含有statci的函数和全局变量不能声明为extern c

另一个是让函数和变量按照C方式编译连接，C++是支持函数重载的，经过C++编译后的函数名称会发生变化，根据函数名，参数化类型重载，而C编译方式不会是名字发生变化。

使用 extern C 按照C的方式编译。

（3）sizeof对指针，数组的用法

   sizeof() 指针是4个字节 ，数组是数组定义的长度，但是当数组作为函数参数的时候就会变为了指针。

（4）求1的个数（x&(x-1)）

   

int fun(int x)
{
	int k = 0;
	while(x)
	{
		k++;
		x = (x&(x-1));
	}
	return k;
}

void main()
{
	int a = 9;
	int m = fun(a);
	cout<<m<<endl;
}

 

程序设计：

（1）堆排序

  

void sift(int r[] ,int k ,int m)
{
   int i ,j,x;
   int t;
   bool finished = false;
   i = k;
   j = 2*i;
   t= r[k];
   x =t;
   while(j<= m &&(!finished))
   {
	   if((j<m)&&(r[j]>r[j+1]))
	   {
		   j =j+1;
	   }
	   if(x<=r[j])
	   {
		   finished = true;
	   }
	   else
	   {
		   r[i] = r[j];
		   i = j;
		   j = 2*i;
	   }
   }
   r[i] = t;

}

void heapsort(int c[] ,int n)
{
	int i ,m,t;
	m = n/2;
	for(i = m;i>= 1;i--)
	{
		sift(c , i , n);
	}
	for(i = n ;i>=2 ;i--)
	{
		t = c[i];
		c[i] = c[1];
		c[1] = t;
		sift(c, 1, i-1);
	}


}

void main()
{

	 int a[]={0,51,38,49,27,62,5,16,38};
 
	heapsort(a,8);
	int i=0;
	for(i = 1 ;i<=8;i++)
	{
		cout<<a[i]<<endl;;
	}

}

 

（2）求有环链表第一个入环节点

// 首先要找到是否有环，并找到在换上相同的那个节点，并返回节点
node *is_findx_circle(node *head)
{
             node *p1,*p2,*p;
             p1 = head->next;
             p2=head->next->next;
             while(p1 !=NULL && p2!= NULL)
             {
                    if( p1==p2 )
                    {
                            p = p1;
                    }
                    p1 = p1->next;
                     p2=p2->next->next;
                     
             }
             return p;
}


// 找出点链表中第一个相交的点
node *find_frist(node *head1 ,node *head2)
{
            int len1 ,len2,i ;
            node *p1,*p2;
            p1 = p1->next;
            p2 = p2->next;
            len1 = length(head1);
            len2 = length(head2);
            if(len1 > len2)
            {
                   for(i = 0 ; i <len1-len2 ; i++)
                    {
                          p1 = p1->next;
                    }
            }
            if(len2>len1)
            {
                   for( i =0;i<len2-len1 ; i++)
                   {
                          p2 = p2->next;
                   }
            }
            while( (p1 != NULL) && (p2 != NULL) )
           {
                  if(p1==p2)
                  {
                         return p1;
                         break;
                  }
                  else
                 {
                        p1 = p1->next;
                        p2 = p2->next;
                 }
           }
}

 

（3）atol的写法

程序设计题注意把自己的思路展示出来。

一面：

（1）c语言static，const用法

   static 静态变量或者函数，只能在本模块或者函数使用，

const  防止变量被随意的改变

（2）const char *p，char *const p的意义和用法

    const char *p 说明 指针指向的内容是不能够改变的

  char *const p 说明指针是不能够被改变的

（3）遇到过哪些警告：答曰：类型不匹配，精度丢失

（4）C语言中的默认全局作用域，为什么会成立？编译器角度来分析？其实与extern c的用法一样。

    c 中没有定义static ,extern 那么这变量是全局变量，是从定义开始到当前文件结尾处。

  static 是将全局变量的作用域限制在了定义到当前文件结尾处，并且不能能使用exttern 来声明.

extern声明一个在别处定义的了的全局变量，不进行定义，只是扩展了使用范围。

要求区分编译错误和链接错误。

（5）我没有答对：

[cpp] view plain copy print ?

1. void foo(int *p){  
2. //dosomething    
3. }  

void foo(int *p){
//dosomething 
}

现在主函数是

[cpp] view plain copy print ?

1. int main(){  
2.     char c = 1;  
3.     foo(&c);  
4. }  

int main(){
    char c = 1;
    foo(&c);
}

有啥问题？

我说的还是类型不匹配，恩，面试官认为太泛了。

我说类型对于指针式非常重要的，只有编译器知道了指针的类型，才知道一次处理，如自增操作，走几步？（其实，这里，如果我相当此时如果打印指针内容，指针的类型同样要决定函数要读入地址的内容的几个字节，这就是面试官要得答案。如char p，那么只会读取p所指地址的1个字节，但是int p会读取p所指向地址的4分字节）

正解为：foo中调用的时候，希望传入的是1,但是实际上想foo函数传递参数的时候，会把&c后面的3个字节的内容也传入，这是垃圾信息，这样就会出现隐晦的bug。当然，编译器肯定会警告。

测试用例：

[cpp] view plain copy print ?

1. # include <stdio.h>   
2. void foo(int *p){  
3.     printf("%d",*p);  
4. }  
5. int main(){  
6.     char c = 1;  
7.     foo(&c);  
8.     return 0;  
9. }  

# include <stdio.h>
void foo(int *p){
	printf("%d",*p);
}
int main(){
	char c = 1;
	foo(&c);
	return 0;
}

输出结果：

-42991615

而且这个还是随时变化的。

第一面收获：

就是最后一个题目了，以前觉得C的基础还不错，还是有没有考虑到的地方。

另外我看见自己的编程大题目得分很低，看来需要把自己的思路展示出来。其实最后2道题目都比较容易解决