常见笔试面试

【C语言部分】

一、概念问答题：

static在C和C++里各代表什么含义 （语言）

答:C中：static (1)局部静态变量 (2)外部静态变量/函数  C++中：静态数据成员/成员函数 

const在C/C++里什么意思（语言）

答：

在C中： const的用法主要有两种：

(1)在定义变量时使用（由于 const常量在定义后不能被改变，所以在定义是一定要进行初始化）

a)说明变量为一个常变量（具有常属性）： int const a=100和const int a = 100 并无区别

b)说明指针为指向常数的指针，即指针本身的值是可以改变的

const int *a=&b;

c)说明指针本身的值不可改变，但指向的内容可改变： int * const a=&b;

d)说明指针为指向常熟的常指针，即指针本身与指针指向的内容都不可改变： const int *const a =&b;

在C++中说明引用为常数引用，即不能改变引用的值。 const int &a=100;

2).定义函数是使用：

a)作为参数使用，说明函数体内是不能修改该参数的： void func(const int a)

b)作为返回值使用，说明函数的返回值不能修改： const int function()

c)在函数中使用const，大多都是跟 &配对的

C++中区别于C 的const用法主要分为以下两种

1)、const 类成员

   const类成员在对象构造期间允许被初始化并且在以后不允许被改变。 const类成员和一般的const 变量有所不同。 const类成员是对应于每个对象而言，它在对象构造期间被初始化，在这个对象的生存周期中不允许被改变。

2)、 const 成员函数

const 成员函数不允许在此函数体内对此函数对应的类的所有成员变量进行修改，这样可以提高程序的健壮性。 Const一般放在函数体后：

functionType   fun()   const 。

3)、const 在C和 C++中最大的不同是，在C中， const默认具有外部链接，而C++ 中则是内部链接。所以当你只在定义const常量的文件中使用该常量时， c++不给你的const 常量分配空间，此时 const int c = 0；相当于#define c 0 ；而在C中，它会给每个 const 常量分配内存空间。

简单总结一下const的用法：

（1）定义常量

（2）指针相关

（3）形参相关

（4）函数相关

volatile关键字的作用（语言）

答:防止编译器优化。

new&delete 和malloc&free的区别

答：它们都是动态管理内存的入口。

Malloc/free是C标准库的函数，new/delete是C++运算符。

Malloc/free需要手动计算空间的大小，new/delete可自动计算类型的大小。

Malloc/free的返回值是void*，new的返回值是对象类型的指针。

Malloc/free只是动态分配内存空间/释放空间。而new/delete除了分配内存空间还会调用构造函数和析构函数进行初始化。

随便写一个函数指针、指针数组和数 组指针

答：int (*pfun)(), int *p[],int (*p)[].

你觉得指针和数组相同吗？

讲讲你理解的指针。

答：指针是一个特殊的变量，它里面存储的树枝被解释为内存里的地址。要搞清指针需要搞清四方面的内容：指针的类型，指针所指向的类型，指针的值（指针所指的内存区），指针本身所占据的区。

const和＃define有什么不同？

答：(1)编译器处理方式不同：define宏是在预处理阶段展开。Const常量是编译运行阶段使用。(2)类型和安全检查不同：define宏没有类型，不做任何类型检查，仅仅展开。Const常量具有类型，在编译阶段去执行类型检查。（3）存储类型不同：const常量是在内存中分配（堆/栈），define有多少地方使用，就展开多少次。(4)const可以节省空间，避免不必要的内存分配。

const 与 #define的比较

    C++ 语言可以用const来定义常量，也可以用 #define来定义常量。但是前者比后者有更多的优点：

（1）   const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误（边际效应）。

（2）   有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。

二、编程题：

1.求数组（元素可为正数、负数、0）的最大子序列和。

int maxSubSum(const vector<int>& a)

{

       int maxSum = 0;

       for (int i = 0; i < a.size(); ++i)

       {

              for (int j = i; j < a.size(); j++)

              {

                     int thisSum = 0;

                     for (int k = 0; k <= j; ++k)

                     {

                            thisSum += a[k];

                     }

                     if (thisSum > maxSum)

                     {

                            maxSum = thisSum;

                     }

              }

       }

       return maxSum;

}

 

int  main()

{

        vector < int > a = { -2, 11, -4, 13, -5, -2 };

        int  ret = maxSubSum(a);

       cout << ret << endl;

        return  0;

}

2.写一个针对整数的快速排序。

int Partition(int arr[], int low, int high)

{

       int key = arr[low];

       while (low < high)

       {

              while (low<high && arr[high] >= key)

              {

                     high--;

              }

              arr[low] = arr[high];

              while (low < high && arr[low] <= key)

              {

                     low++;

              }

              arr[high] = arr[low];

       }

       arr[low] = key;

       return low;

}

 

void QSort(int arr[], int low, int high)

{

       if (low < high)

       {

              int keyloc = Partition(arr,low,high);

 

              QSort(arr,low,keyloc-1);

              QSort(arr, keyloc + 1, high);

       }

}

 

int main()

{

       int arr[] = { 15, 8, 19, 20, 12, 10, 9, 7 };

       QSort(arr, 0, 7);

       for (int i = 0; i < sizeof(arr) / sizeof(int); ++i)

       {

              cout << arr[i] << " ";

       }

       cout << endl;

}

3. 编写一个memmove函数，实现内存拷贝。

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

{

              void * ret =  dst ;

              assert (  dst );

              assert (  src );

              if  (  dst  <=  src  || (  char *)  dst  >= ((  char *)  src  +  count ))

            {

                          while  (  count --)

                        {

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

                                      dst  = (  char  *)  dst  + 1;

                                      src  = (  char  *)  src  + 1;

                        }

            }

              else                     //源内存的首地址小于目标内存的首地址，反向拷贝

            {

                          dst  = (  char *)  dst  +  count  - 1;

                          src  = (  char *)  src  +  count  - 1;

                          while  (  count --)

                        {

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

                                      dst  = (  char *)  dst  - 1;

                                      src  = (  char *)  src  - 1;

                        }

            }

              return  ret;

}

int  main()

{

              char  str1[] =  "abcdef" ;

              char  str2[] =  "hijekie" ;

            memmove(str2, str1, 4);

            cout <<  "new str2 is :" << str2 << endl;

}

4.编写一个函数求解第n个非波那契数字。

递归算法：

int Fibonacci(int n)

{

       if (n == 0)

              return 0;

       else if (n == 1 || n == 2)

       {

              return 1;

       }

       else

       {

              return Fibonacci(n - 1) + Fibonacci(n - 2);

       }

}

 

int main()

{

       int ret = Fibonacci(8);

       cout << ret << endl;

       return ret;

}

非递归算法：

int Fibonacci(int n)

{

       int f1 = 0;

       int f2 = 1;

       int f3;

 

       for (int i = 2; i <= n; ++i)

       {

              f3 = f1 + f2;

              f1 = f2 ;

              f2 = f3;

       }

       return f3;

}

数组实现：

int Fibonacci(int n)

{

       int fibArray[3] = { 0, 1, n };

       for (int i = 2; i <= n; ++i)

       {

              fibArray[2] = fibArray[0] + fibArray[1];

              fibArray[0] = fibArray[1];

              fibArray[1] = fibArray[2];

       }

       return fibArray[2];

}

【C++/数据结构】

     【1.C++基础知识】
1.     什么时候使用引用作为函数参数？
2.     什么时候使用引用做函数返回值？
3.     使用引用做函数返回值要注意些什么问题？
4.     什么时候使用常引用？
5.     引用和指针的区别和联系？
答：从概念上来讲，指针是一个实体，指针存储变量的地址；引用是一个别名。
引用只能在定义时初始化一次，之后不能改变指向其它变量（从一而终）；指针变量的值可变，可以指向其它对象。
引用必须指向有效的变量，指针可以为空。sizeof指针对象和引用对象的意义不一样。sizeof指针是对象地址的大小。sizeof引用得到的是指向变量的大小。
指针和引用自增和自减意义不一样。相对而言，引用比指针安全。

6.     const定义常量和#define 定义宏的优缺点？
7.     C++中使用哪些技术可以替代宏？为什么建议使用使用这些技术去替代宏？
答：使用const/enum/inline function可以替代宏。Const和enum替代宏常量，inline function 替代宏函数。
(1)     宏不可以调试查看，const/enum/inline function可以调试。
(2)     写宏函数容易出错，代码的可读性和可维护性差。
(3)     宏常量和宏函数缺少类型安全的检查，使用const/enum/inline function时编译器会进行类型安全的检查。
8.     malloc/free和new/delete的区别和联系？
9.     在C++程序中调用被C编译器编译后的函数，为什么要加extern"c"？

答：C++支持函数重载，C语言不支持函数重载。C++为了支持函数重载，按照不同编译器的函数修饰规则，对函数名进行了处理，加入函数的参数类型进行修饰。这里函数是被C编译器编译的，编译后函数名没有进行修饰，所以加extern”c”告诉编译器使用C的方式进行查找链接。