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

1. 编写一个函数，实现将ASCII码字符串转化为带符号的整数。

    int StrToInt (const char* pStr);

   传递给StrToInt的字符串只包含数字和‘-’(负号)，是一个格式正确的整数值。

#include <iostream>
using namespace std;

int StrtoInt(const char *str)
{
    int Result = 0;
    int i = 0;
    bool m_bMinus = false;

    if (*str == '-')
    {
        m_bMinus = true;
        i++;
    }

    while (*(str + i) != '\0')
    {
        Result = Result * 10 + *(str+i) - '0';
        i++;
    }

    if (m_bMinus)
    {
        Result = 0 - Result;
    }

    return Result;
}

int main()
{
    char str[] = "-54567";
    int r;
    r = StrtoInt(str);
    cout<<r<<endl;

    return 0;
}

2. 编写一个函数，实现将一个整数转换为ASCII码字符串。

   int IntToStr (int num, char* pStr);

   已知条件：传递给IntToStr函数的缓冲区的长度是能够容纳int整数范围内的数。

 

#include <iostream>
#include <math.h>
using namespace std;

int IntToStr(int num, char *pStr)
{
    int m_bMinus = false;
    int i = 0;
    int len;
    char *tmp = pStr;

    if (num < 0)
    {
        m_bMinus = true;
        num = abs(num);
    }

    while (num)
    {
        tmp[i++] = num % 10 + '0';
        num /= 10;
    }
    tmp[i] = '\0';

    len = strlen(tmp);
    for (int j = 0; j < len/2; j++)
    {
        char ch;
        ch = tmp[j];
        tmp[j] = tmp[len - 1 - j];
        tmp[len -1 - j] = ch;
    }

    if (m_bMinus)
    {
        tmp[len+1] = '\0';
        for (int k = len - 1; k >= 0; k--)
        {
            tmp[k+1] = tmp[k];
        }
        tmp[0] = '-';
    }

    return 0;
}

int main()
{
    char pStr[20];
    IntToStr(-12345, pStr);
    cout<<pStr<<endl;

    return 0;
}

3. 编程实现二分法搜索函数，该函数对一个排序好的整数数组进行二分搜索（binary Search）,函数的原型如下：

    int BinarySearch(const int* array, int lower, int upper, int target);

其中lower、upper分别是需要进行搜索的开始和结束的索引值，请分别使用递归和非递归两种方法实现该函数。

非递归：

#include <iostream>
using namespace std;

int BinarySearch(const int* array, int lower, int upper, int target)
{
    int mid;
    int index = -1;
    while (lower <= upper)
    {
        mid = (lower + upper) / 2;
        if (array[mid] == target)
        {
            index = mid;
            return index;
        }
        else if (array[mid] < target)
        {
            lower = mid + 1;
        }
        else if (array[mid] > target)
        {
            upper = mid - 1;
        }
    }

    return index;
}

int main()
{
    int arr[10] = {2,5,7,10,12,15,17,19,25,58};
    int index;
    index = BinarySearch(arr, 0, 9, 15);
    cout<<index<<" "<<arr[index]<<endl;

    return 0;
}

递归：

#include <iostream>
using namespace std;

int BinarySearch(const int* array, int lower, int upper, int target)
{
    int mid, index = -1;

    while (lower <= upper)
    {
        mid = (lower + upper) / 2;
        if (array[mid] == target)
        {
            index = mid;
            return index;
        }
        else if (array[mid] < target)
        {
            return BinarySearch(array, mid + 1, upper, target);
        }
        else if (array[mid] > target)
        {
            return BinarySearch(array, lower, mid - 1, target);
        }
    }

    return index;
}


int main()
{
    int arr[10] = {2,5,7,10,12,15,17,19,25,58};
    int index;
    index = BinarySearch(arr, 0, 9, 17);
    cout<<index<<" "<<arr[index]<<endl;

    return 0;
}

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);

     }