【C/C++】程序员经典面试题，过来人的总结...

目录

序

嗨，这里是狐狸~~

一、找错题

试题1：

试题2：

试题3：

试题4：

试题5：

试题6：

试题7：

二、技巧题

试题1：写一个函数返回1+2+3+…+n的值（假定结果不会超过长整型变量的范围）

试题2：写一个函数找出一个整数数组中第二大的数

试题3：编写strcpy函数

试题4：华为面试题：怎么判断链表中是否有环？

试题5：写一个内存拷贝函数memcpy()，不用任何库函数

试题6：写出二分查找的代码

试题7：编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：

 三、知识题

试题1：请说出static和const关键字尽可能多的作用

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

试题 3：sizeof 和 strlen 的区别

试题 4：Ｃ中的 malloc 和Ｃ＋＋中的 new 有什么区别

试题 5：谈谈你对拷贝构造函数和赋值运算符的认识

总结​

---

序

青春，一半明媚，一半忧伤。

嗨，这里是狐狸~~

        今天是2022年的1月14日，今天是个好日子呀，阳光明媚，微风不燥，太阳出来的那一刻心都融化了似的，希望每天都可以像今天一样美好吧。

       今天给大家讲一下C/C++程序员会遇到的面试题，都是一些常见的题目，大家可以把答案藏住自己先做一遍，效果应该会很好的。

一、找错题

试题1：

void test1()
{
　charstring[10];
　char* str1 ="0123456789";
　strcpy( string, str1 );
}

试题2：

void test2()
{
　charstring[10],str1[10];
　int i;
　for(i=0; i<10; i++)
　{
　　str1 ='a';
　}
　strcpy( string, str1 );
}

试题3：

void test3(char* str1)
{
　charstring[10];
　if( strlen( str1 ) <=10 )
　{
　　strcpy( string, str1 );
　}
}

解答：
　　试题1字符串str1需要11个字节才能存放下（包括末尾的’\0’），而string只有10个字节的空间，strcpy会导致数组越界；

　　对试题2，如果面试者指出字符数组str1不能在数组内结束可以给3分；如果面试者指出strcpy(string,str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10分；

　　对试题3，if(strlen(str1)<= 10)应改为if(strlen(str1) < 10)，因为strlen的结果未统计’\0’所占用的1个字节。

剖析：
　　考查对基本功的掌握：
　　(1)字符串以’\0’结尾；
　　(2)对数组越界把握的敏感度；
　　(3)库函数strcpy的工作方式，如果编写一个标准strcpy函数的总分值为10，下面给出几个不同得分的答案：

试题4：

void GetMemory( char*p )
{
　p = (char*) malloc( 100 );
}
void Test( void ) 
{
　char*str = NULL;
　GetMemory( str ); 
　strcpy( str, "hello world" );
　printf( str );
}

试题5：

char*GetMemory( void )
{ 
　char p[] ="hello world"; 
　return p; 
}
void Test( void )
{ 
　char*str = NULL; 
　str = GetMemory(); 
　printf( str ); 
}

试题6：

void GetMemory( char**p, int num )
{
　*p = (char*) malloc( num );
}
void Test( void )
{
　char*str = NULL;
　GetMemory( &str, 100 );
　strcpy( str, "hello" ); 
　printf( str ); 
}

试题7：

void Test( void )
{
　char*str = (char*) malloc( 100 );
　strcpy( str, "hello" );
　free( str ); 
　... //省略的其它语句
}

解答：

试题4    传入中GetMemory(char *p )函数的形参为字符串指针，在函数内部修改形参并不能真正的                改变传入形参的值，执行完

                char *str = NULL;
                GetMemory( str ); 

               后的str仍然为NULL；

试题5中

            char p[] = "hello world"; 
           return p; 　的p[]数组为函数内的局部自动变量，在函数返回后，内存已经被释放。这是许多              程序员常犯的错误，其根源在于不理解变量的生存期。

试题6   的GetMemory避免了试题4的问题，传入GetMemory的参数为字符串指针的指针，但是在                GetMemory中执行申请内存及赋值语句

              *p = (char *) malloc( num );

            后未判断内存是否申请成功，应加上：

           if ( *p == NULL )
          {
　               ...//进行申请内存失败处理
             }

试题7    存在与试题6同样的问题，在执行

              char *str = (char *) malloc(100)；后未进行内存是否申请成功的判断；另外，在free(str)后                 未置str为空，导致可能变成一个“野”指针，应加上：

               str = NULL;

剖析：
　　试题4～7考查面试者对内存操作的理解程度，基本功扎实的面试者一般都能正确的回答其中50~60的错误。但是要完全解答正确，却也绝非易事。

对内存操作的考查主要集中在：
      1）指针的理解；

      2）变量的生存期及作用范围；

      3）良好的动态内存申请和释放习惯。

二、技巧题

试题1：写一个函数返回1+2+3+…+n的值（假定结果不会超过长整型变量的范围）

解答：

int Sum( int n )
{ 
　return ( (long)1+ n) * n /2;　　//或return (1l + n)* n / 2;
}

剖析：
　　对于这个题，只能说，也许最简单的答案就是最好的答案。下面的解答，或者基于下面的解答思路去优化，不管怎么“折腾”，其效率也不可能与直接return( 1 l + n ) * n / 2相比！

int Sum( int n )
{
　long sum =0;
　for( int i=1; i<=n; i++ )
　{
　　sum += i;
　}
　return sum;
}

试题2：写一个函数找出一个整数数组中第二大的数

　　如：a[10]={1,2,3,4,5,6,7,8,9,10}  ==> nextmax = 9;

　　　　a[10]={1,2,3,4,5,6,7,10,10,10}  ==> nextmax = 7;

　　　　a[10]={8,8,8,2,8,8,8,8,8,8}  ==> nextmax = 2;

　　　　a[10]={8,8,8,8,8,8,8,8,8,8}  ==> nextmax = 不存在;

// C语言实现如下
#include <stdio.h>
#include <stdlib.h>

int getmax(int *p, int n)
{
    //假定第一个数最大，与剩下的数逐一进行比较
    int maxdata = p[0];    //最大数的值
    int maxi = 0;        //最大数的下标

    for (int i = 1; i < n; i++)
    {
        if (maxdata<p[i])
        {
            maxdata = p[i];
            maxi = i;
        }
    }

    return maxi;    //返回下标
}

void swap(int *p1, int *p2)    //根据地址交换两个变量
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}


void main()
{
    int a[10] = { 8,8,8,8,5,8,8,8,8,8 };
    //printf("%d\n", getmax(a, 10));
    int maxi = getmax(a, 10);    //保留最大值的下标
    int max = a[getmax(a, 10)];    //保留最大值

    swap(&a[0], &a[maxi]);

    int i = 1;
    int flag = 0;    //0代表没有第二大的数，比如全部相同时
    while (i<10)
    {
        int nextmaxi = i + getmax(a + i, 10-i);    //注意下标+1
        int nextmax = a[nextmaxi];

        if (max != nextmax)
        {
            printf("\nnextmax = %d", nextmax);
            flag = 1;    //代表数组并非全部相同
            break;
        }

        swap(&a[i],&a[nextmaxi]);
        i++;
    }

    if (!flag)
    {
        printf("next max不存在");
    }

    system("pause");
    return ;
}

试题3：编写strcpy函数

　　已知strcpy函数的原型是char *strcpy(char *strDest,char *strSrc);其中strDest是目的字符串，strSrc是源字符串。

　　（1）不调用C/C++的字符串库函数，请编写出函数strcpy

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

char *strcpy(char *strDest,char *strSrc)
{
    assert((strDest != NULL) && (strSrc != NULL));    //异常处理
    //if ((strDest == NULL) && (strSrc == NULL))
    //{
    //    cout << "异常..." << endl;
    //}

    char *address = strDest;
    while ((*strDest++ = *strSrc++) != '\0')    //牛掰的语句，并没有把语句放在循环体中
        NULL;
    return address;
}

void main()
{
    char str1[] = "hello world";
    char str2[20];

    cout << str1 << endl;
    strcpy(str2, str1);
    cout << str2 << endl;

    system("pause");
    return ;
}

（2）strcpy()函数能把strSrc的内容复制到strDest，为什么还要用char * 类型的返回值？

　　　　答案：为了实现链式表达式，如：

int length = strlen(strcpy(str2, str1));

试题4：华为面试题：怎么判断链表中是否有环？

　　答：用两个指针来遍历这个单向链表，第一个指针p1，每次走一步；第二个指针p2，每次走两步；  当p2 指针追上 p1的时候，就表明链表当中有环路了。

int testLinkRing(Link *head)
{
    Link *t1 = head, *t2 = head;
    while (t1->next && t2->next)
    {
        t1 = t1->next;
        if (NULL == (t2 = t2->next->next))
            return 0;   //无环
        if (t1 == t2)
            return 1;   //有环
    }
 
    return 0;
}

试题5：写一个内存拷贝函数memcpy()，不用任何库函数

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

//内存拷贝函数：
//功能：由src指向地址为起始地址的连续n个字节的数据复制到以destin指向地址为起始地址的空间内。
//返回值：函数返回一个指向dest的指针
//与strcpy相比：memcpy并不是遇到'\0'就结束，而是一定会拷贝完n个字节
//memcpy用来做内存拷贝，可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度
void *memcpy(void *dest, const void *src, size_t size)
{
    assert((dest != NULL) && (src != NULL));

    char *pdest = (char *)dest;
    char *psrc = (char *)src;

    while ( (size--) > 0 )
    {
        *pdest++ = *psrc++;
    }

    return pdest;
}

void main()
{
    char str1[10] = "abcdefghi";
    char str2[20];

    memcpy(str2, str1, sizeof(str1));
    cout << str1 << endl;                //abcdefghi
    cout << str2 << endl;                //abcdefghi

    //若改为如下：
    char str3[20] = "abcdefghi";
    char str4[10];

    memcpy(str4, str3, sizeof(str3));    //此时会造成str4内存地址溢出

    cout << str3 << endl;                
    cout << str4 << endl;                

    system("pause");
    return ;
}

【解析】

面试中如问到memcpy的实现，要小心了，这里有陷阱。标准的memcpy()函数中，对于地址重叠的情况，该函数的行为是未定义的。事实上陷阱也在于此，自己动手实现memcpy()时就需要考虑地址重叠的情况。

　　库函数中的memcpy不能处理src和dest有重叠的情况。如果是自己实现memcpy的话，最好还是把地址有重叠的情况考虑进去，这样才能更好的体现编码的严谨。

//把地址有重叠的情况考虑进去
void *memcpy(void *dest, const void *src, size_t size)
{
    assert((dest != NULL) && (src != NULL) && (size > 0) );    //添加了size > 0的条件

    char *pdest, *psrc;

    if ((dest > src) && ((char *)dest < (char *)src + size))            //有内存重叠，则从后向前拷贝
    {
        pdest = (char *)dest + size - 1;    //指针指向拷贝的最后一个位置
        psrc = (char *)src + size - 1;        

        while (size--)
        {
            *pdest-- = *psrc--;
        }
    }

    else                                                              //没有内存重叠，从前往后拷贝即可
    {
        pdest = (char *)dest;              //指针指向拷贝的起始位置
        psrc = (char *)src;

        while (size--)
        {
            *pdest++ = *psrc++;
        }
    }

    return pdest;
}

 【扩展】

memmove和memcpy函数都是C语言中的库函数，作用是拷贝一定长度的内存的内容，它们的作用是一样的，唯一的区别就是当内存发生局部重叠的时候，memmove保证拷贝的结果是正确的，memcpy不保证拷贝的结果是正确的。它与memcpy的功能相似，都是将src所指的n个字节复制到dest所指的内存地址起始位置中，但该函数可以处理src和dest有重叠的情况。实际上，memcpy可以看作是memmove的子集。上面优化后的memcpy()函数实际上就是memmove()函数的实现。

试题6：写出二分查找的代码

#include <iostream>
using namespace std;

int binary_search(int *arr, int key, int n)
{
    int low = 0;
    int high = n - 1;
    int mid;

    while (low <= high)
    {
        mid = (low + high) / 2;
        if (key < arr[mid])
            high = mid - 1;
        else if (key > arr[mid])
            low = mid + 1;
        else
            return mid;
    }
    return -1;
}

void main()
{
    int A[] = { 1,3,5,7,9,11,13,15,17 };
    int len = sizeof(A) / sizeof(A[0]);
    int key;

    cout << "数组如下：" << endl;
    for(int i=0;i<len;i++)
        cout << A[i] << " ";
    cout << endl;

    cout << "请输入待查找的关键字key:" << endl;
    cin >> key;

    int ret=binary_search(A, key, len);

    if (-1 == ret)
        cout << "没有找到，数组中无关健值" << key << endl;
    else
        cout << "已找到关键值" << key << ",它是A[" << ret << "]" << endl;
    
    system("pause");
    return ;
}

试题7：编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：

class String
{ 
　public: 
　　String(constchar*str = NULL); // 普通构造函数 
　　String(const String &other); // 拷贝构造函数 
　　~ String(void); // 析构函数 
　　String & operator =(const String &other); // 赋值函数 
　private: 
　　char*m_data; // 用于保存字符串 
};

解答：

//普通构造函数
String::String(constchar*str) 
{
　if(str==NULL) 
　{
　　m_data =newchar[1]; // 得分点：对空字符串自动申请存放结束标志'\0'的空
　　//加分点：对m_data加NULL 判断
　　*m_data ='\0'; 
　} 
　else
　{
　　int length = strlen(str); 
　　m_data =newchar[length+1]; // 若能加 NULL 判断则更好 
　　strcpy(m_data, str); 
　}
}
// String的析构函数
String::~String(void) 
{
　delete [] m_data; // 或deletem_data;
}
//拷贝构造函数
String::String(const String &other) 　　　// 得分点：输入参数为const型
{ 
　int length = strlen(other.m_data); 
　m_data =newchar[length+1]; 　　　　//加分点：对m_data加NULL 判断
　strcpy(m_data, other.m_data); 
}
//赋值函数
String & String::operator =(const String &other) // 得分点：输入参数为const型
{ 
　if(this==&other) 　　//得分点：检查自赋值
　　return*this; 
　delete [] m_data; 　　　　//得分点：释放原有的内存资源
　int length = strlen( other.m_data ); 
　m_data =newchar[length+1]; 　//加分点：对m_data加NULL 判断
　strcpy( m_data, other.m_data ); 
　return*this; 　　　　　　　　//得分点：返回本对象的引用
}

剖析：
　　能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！
　　在这个类中包括了指针类成员变量m_data，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective　C++》中特别强调的条款。
　　仔细学习这个类，特别注意加注释的得分点和加分点的意义，这样就具备了60%以上的C++基本功！ 

 三、知识题

试题1：请说出static和const关键字尽可能多的作用

解答：
　  　static关键字至少有下列n个作用：
　　（1）函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一                     次，因此其值在下次调用时仍维持上次的值；
　　（2）在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
　　（3）在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在                     声明它的模块内；
　　（4）在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
　　（5）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类                    的static成员变量。

　　const关键字至少有下列n个作用：
　　（1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它                       进行初始化，因为以后就没有机会再去改变它了；
　　（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者                       同时指定为const；
　　（3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改                       变 其值；
　　（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成                      员变量；
　　（5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左                          值”。例如：

                    const classA operator*(const classA& a1,const classA& a2);

              operator*的返回结果必须是一个const对象。如果不是，这样的变态代码也不会编译出错：

                 classA a, b, c;
                  (a * b) = c; // 对a*b的结果赋值
　　操作(a * b) = c显然不符合编程者的初衷，也没有任何意义。

剖析：
　　惊讶吗？小小的static和const居然有这么多功能，我们能回答几个？如果只能回答1~2个，那还真得闭关再好好修炼修炼。

　　这个题可以考查面试者对程序设计知识的掌握程度是初级、中级还是比较深入，没有一定的知识广度和深度，不可能对这个问题给出全面的解答。大多数人只能回答出static和const关键字的部分功能。

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

解答：

　　　BOOL型变量：if(!var)

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

　　　float型变量：

　　　const float EPSINON = 0.00001;

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

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

剖析：

　　考查对0值判断的知识，BOOL型变量的0判断完全可以写成if(var==0)，而int型变量也可以写成if(!var)，指针变量的判断也可以写成if(!var)，上述写法虽然程序都能正确运行，但是未能清晰地表达程序的意思。 
　一般的，如果想让if判断一个变量的“真”、“假”，应直接使用if(var)、if(!var)，表明其为“逻辑”判断；如果用if判断一个数值型变量(short、int、long等)，应该用if(var==0)，表明是与0进行“数值”上的比较；而判断指针则适宜用if(var==NULL)，这是一种很好的编程习惯。

　　浮点型变量并不精确，所以不可将float变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。如果写成if(x == 0.0)，则判为错，得0分。

试题 3：sizeof 和 strlen 的区别

   sizeof 和 strlen 有以下区别：

1. sizeof 是一个操作符，strlen 是库函数。
2. sizeof 的参数可以是数据的类型，也可以是变量，而 strlen 只能以结尾为‘\0‘的字符串作参数。
3. 编译器在编译时就计算出了 sizeof 的结果。而 strlen 函数必须在运行时才能计算出来。并且 sizeof

计算的是数据类型占内存的大小，而 strlen 计算的是字符串实际的长度。

       数组做sizeof 的参数不退化，传递给strlen 就退化为指针了。

注意：有些是操作符看起来像是函数，而有些函数名看起来又像操作符，这类容易混淆的名称一定   要加以区分，否则遇到数组名这类特殊数据类型作参数时就很容易出错。最容易混淆为函数的操作符就   是 sizeof。

试题 4：Ｃ中的 malloc 和Ｃ＋＋中的 new 有什么区别

malloc 和 new 有以下不同：

1.    new、delete 是操作符，可以重载，只能在 C++中使用。
2. malloc、free 是函数，可以覆盖，C、C++中都可以使用。
3. new 可以调用对象的构造函数，对应的 delete 调用相应的析构函数。
4. malloc 仅仅分配内存，free 仅仅回收内存，并不执行构造和析构函数
5. new、delete 返回的是某种数据类型指针，malloc、free 返回的是void 指针。

注意：malloc 申请的内存空间要用 free 释放，而 new 申请的内存空间要用 delete 释放，不要混用。因为两者实现的机理不同。

试题 5：谈谈你对拷贝构造函数和赋值运算符的认识

拷贝构造函数和赋值运算符重载有以下两个不同之处：

1. 拷贝构造函数生成新的类对象，而赋值运算符不能。
2. 由于拷贝构造函数是直接构造一个新的类对象，所以在初始化这个对象之前不用检验源对象  是否和新建对象相同。而赋值运算符则需要这个操作，另外赋值运算中如果原来的对象中有内存分配要   先把内存释放掉

注意：当有类中有指针类型的成员变量时，一定要重写拷贝构造函数和赋值运算符，不要使用默认 的。

总结

         博观而约取，厚积而薄发，希望这些题目可以帮助到大家，也希望大家在编程这条路上都可以越走越远，脚踏实地，走好每一步，不要盲目的前进，学习要有方向，有了方向前进的路才会有奔头，好吧，感谢大家的一路支持吧，后续我还会发布更多的项目源或者学习资料，希望大家可以持续关注，有什么问题可以回帖留言。领取C/C++学习资料以及其他项目的源码的可以加群【1083227756】了解。想要对程序员的未来发展有兴趣的可以关注微信公众号：【狐狸的编码时光】，希望和大家一起学习进步！