联发科技09年手机软件开发笔试题

时间  2019-12-12
标签 科技 09年 手机 软件开发 笔试 栏目 快乐工作 繁體版
原文   原文链接
1. 编写一个函数，实现将ASCII码字符串转化为带符号的整数。
    int StrToInt (const char* pStr);
   传递给StrToInt的字符串只包含数字和‘-’(负号)，是一个格式正确的整数值。
  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int StrtoInt(const char *str)
  5. {
  6.     int Result = 0;
  7.     int i = 0;
  8.     bool m_bMinus = false;
  9.  
  10.     if (*str == '-')
  11.     {
  12.         m_bMinus = true;
  13.         i++;
  14.     }
  15.  
  16.     while (*(str + i) != '\0')
  17.     {
  18.         Result = Result * 10 + *(str+i) - '0';
  19.         i++;
  20.     }
  21.  
  22.     if (m_bMinus)
  23.     {
  24.         Result = 0 - Result;
  25.     }
  26.  
  27.     return Result;
  28. }
  29.  
  30. int main()
  31. {
  32.     char str[] = "-54567";
  33.     int r;
  34.     r = StrtoInt(str);
  35.     cout<<r<<endl;
  36.  
  37.     return 0;
  38. }
2. 编写一个函数，实现将一个整数转换为ASCII码字符串。
   int IntToStr (int num, char* pStr);
   已知条件：传递给IntToStr函数的缓冲区的长度是可以容纳int整数范围内的数。
 
  1. #include <iostream>
  2. #include <math.h>
  3. using namespace std;
  4.  
  5. int IntToStr(int num, char *pStr)
  6. {
  7.     int m_bMinus = false;
  8.     int i = 0;
  9.     int len;
  10.     char *tmp = pStr;
  11.  
  12.     if (num < 0)
  13.     {
  14.         m_bMinus = true;
  15.         num = abs(num);
  16.     }
  17.  
  18.     while (num)
  19.     {
  20.         tmp[i++] = num % 10 + '0';
  21.         num /= 10;
  22.     }
  23.     tmp[i] = '\0';
  24.  
  25.     len = strlen(tmp);
  26.     for (int j = 0; j < len/2; j++)
  27.     {
  28.         char ch;
  29.         ch = tmp[j];
  30.         tmp[j] = tmp[len - 1 - j];
  31.         tmp[len -1 - j] = ch;
  32.     }
  33.  
  34.     if (m_bMinus)
  35.     {
  36.         tmp[len+1] = '\0';
  37.         for (int k = len - 1; k >= 0; k--)
  38.         {
  39.             tmp[k+1] = tmp[k];
  40.         }
  41.         tmp[0] = '-';
  42.     }
  43.  
  44.     return 0;
  45. }
  46.  
  47. int main()
  48. {
  49.     char pStr[20];
  50.     IntToStr(-12345, pStr);
  51.     cout<<pStr<<endl;
  52.  
  53.     return 0;
  54. }
3. 编程实现二分法搜索函数，该函数对一个排序好的整数数组进行二分搜索（binary Search）,函数的原型以下：    int BinarySearch(const int* array, int lower, int upper, int target);
其中lower、upper分别是须要进行搜索的开始和结束的索引值，请分别使用递归和非递归两种方法实现该函数。
非递归：
  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int BinarySearch(const int* array, int lower, int upper, int target)
  5. {
  6.     int mid;
  7.     int index = -1;
  8.     while (lower <= upper)
  9.     {
  10.         mid = (lower + upper) / 2;
  11.         if (array[mid] == target)
  12.         {
  13.             index = mid;
  14.             return index;
  15.         }
  16.         else if (array[mid] < target)
  17.         {
  18.             lower = mid + 1;
  19.         }
  20.         else if (array[mid] > target)
  21.         {
  22.             upper = mid - 1;
  23.         }
  24.     }
  25.  
  26.     return index;
  27. }
  28.  
  29. int main()
  30. {
  31.     int arr[10] = {2,5,7,10,12,15,17,19,25,58};
  32.     int index;
  33.     index = BinarySearch(arr, 0, 9, 15);
  34.     cout<<index<<" "<<arr[index]<<endl;
  35.  
  36.     return 0;
  37. }
递归：
  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int BinarySearch(const int* array, int lower, int upper, int target)
  5. {
  6.     int mid, index = -1;
  7.  
  8.     while (lower <= upper)
  9.     {
  10.         mid = (lower + upper) / 2;
  11.         if (array[mid] == target)
  12.         {
  13.             index = mid;
  14.             return index;
  15.         }
  16.         else if (array[mid] < target)
  17.         {
  18.             return BinarySearch(array, mid + 1, upper, target);
  19.         }
  20.         else if (array[mid] > target)
  21.         {
  22.             return BinarySearch(array, lower, mid - 1, target);
  23.         }
  24.     }
  25.  
  26.     return index;
  27. }
  28.  
  29.  
  30. int main()
  31. {
  32.     int arr[10] = {2,5,7,10,12,15,17,19,25,58};
  33.     int index;
  34.     index = BinarySearch(arr, 0, 9, 17);
  35.     cout<<index<<" "<<arr[index]<<endl;
  36.  
  37.     return 0;
  38. }
4. 下面这个程序执行后会有什么错误或者效果
         #define MAX 255
           int main(void)
{
    unsigned char I;
    unsigned char A[MAX];
   
    for(i=0; i<=MAX; i++)
    {
        A[i] = i;
    }
   
    Return 0;
}
存在两个错误，第一：这将是一个无限循环，由于i是无符号的字符型，范围为0—255，当i=255后加1，i又等于了0，因而又知足了循环条件。第二，数组下标访问越界。
5. 在32位小端字节序系统里，
char array[16] ={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}；
char* cp = array;
int* ip = (int*)array;
问：(1)*(cp+2)=?
    (2)*(ip+2)=?
这 涉及指针的运算，当指针p+n时其计算为：p+ n * sizeof(指针指向的类型），因为cp指向的类型为char，因而cp+2 = cp + 2 * sizeof(char),就是至关于cp的初始值向前移动两个字节，因而*(cp+2) = 2;而ip指向的类型为int，因而ip+2 = ip + 2 * sizeof(int) = ip + 8；就是至关于ip的初始值向前移动了8个字节，因而
*(ip+2)=8。
 
6. c是一个char类型的变量，c的取值范围是多少？若是c的值是0xF0,那么 c>>3=? 请给出10进制的答案。
   c的取值范围：-128——127；
   c>>3=-1,缘由：
   c = 0xF0的二进制表示为11110000,右移三位同时由于是带符号的char，因而右移后高位补1，因而获得11111110，最高位为1，因而是负 数，负数是以补码的形式存储，因而按求负数补码的反步骤计算该负数，对11111110 - 1 = 11111101，在对11111101 取反为 00000010=2，所以为-2。
 
7. 下面函数实现有问题吗？ 若是有问题，实际运行中调用下面函数结果正确，并无出现问题，为何？
int ExchangeValue(int* pa, int* pb)
{
    int* pt;
    if(pa == NULL || pb == NULL)
        return 0;
 
    *pt = *pa;
    *pa = *pb;
    *pb = *pt;
    return 1;
}
有问题：函数中并未对指针pt赋值，让其指向一个整形变量就使用了。
 
8.
    int i1;
    const char* p1 = “AAA”;
    int main()
{
    static int i2;
    int i3;
    int* i4 = malloc(sizeof(int));
    ........ 
}
上面程序中的变量(i1,p1,i2,i3,i4)分别存在于哪些内存存贮位置（数据段、堆栈或堆）？
i1,i2,i3,*i4的值是什么？
i1位于数据段；p1位于数据段；i2位于数据段；i3位于堆栈；i4位于堆。
i1 = 0; i2 = 0;i3随机的；i4是一个指向int类型的地址。
 
9.
下面哪组语句没有编译和运行的错误？若是有错误的组，请说明哪些语句是错误的，为何？
A.     const int a; (1)   //const常量声明的同时必须初始化
B.     char* pa = “AAA”(1)
const char* pb = “BBB”; (2)
pb = pa; (3)
C. char* pa = “AAA”; (1)
   Char* const pb = “BBB”; (2)
   Char* const pc = (char*) malloc(4); (3)
   *pb = ‘A’; (4)
   *(pc+1) = ‘A’;(5)
   Pb = pa;        (6)   //错，由于pc是常量指针，所以不能够改变指向
D. char* pa; (1)
const char* const pb = ”BBB”; (2)
char* const pc; (3)  //错，此时pc被定义为常量指针，在此时必须初始化
pa = “AAA”;(4)
pc = pa;(5)   //错,由于pc是常量指针，不能改变指向
 
 
10.用变量a给出下面的定义： 举例一个整型数  int a;
(1)  一个指向指针的指针，它指向的指针是指向一个整型数   //int **a
(2)  一个有10个整型数的数组         //int a[10]
(3)  一个有10个指针的数组，该指针是指向一个整型数    //int *a[10]
(4)  一个指向有10个整型数组的指针          //int (*a)[10]
(5)  一个指向函数的指针，该函数有一个整型参数并返回一个整型数   //int (*a)(int)
(6)  一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数
    //int (*a[10])(int)
 
11.下面是一个用来删除单向链表头节点的函数，请找出其中程序的漏洞并加以纠正。
        void RemoveHead (node* head)
        {
            free(head);   /* Line1 */
            head = head->next;  /Line2 */
        }
错位在于：已经将head free以后，后面的head->next将出错。
修改成：
     void RemoveHead(node *head)
     {
         p = head;
         head = head->next;
         free(p);
     }
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程