面试2. c++面试（领为军融）

1本段代码是否存在问题？.

#include <iostream>
void  main()
{
    for (unsigned short idx =0;idx <65535; idx++)
    {
        std::cout << idx <<std::endl;
    }
    std::cout<<"Execution completed!"<<std::endl;
}

解析：

(1)可靠性异常（死循环）: 在for循环中，idx变量是unsigned short类型，它的范围是0到65535。当idx达到65535时，再自增会导致它溢出并重置为0。因此，这个循环实际上是一个死循环，永远不会结束。

(2)main函数返回类型错误: main函数应该返回一个整数类型的值，通常是0表示程序正常退出。在您的代码中，main函数的返回类型被省略了，这在C++中是不允许的，编译器将其解释为返回类型为int的函数。

(3)标准库头文件包含不当: 使用时，应包含必要的标准库头文件，如。但是，您提供的代码片段中没有包含任何标准库头文件，这可能导致编译错误。即用using namespace std;
正确写法：

#include <iostream>
using namespace std;                                 //（3）包含头文件的库
int  main()
{
    for (unsigned short idx =0;idx <65535; idx++)   //（1）条件需要增加
    {
        std::cout << idx <<std::endl;
    }
    std::cout<<"Execution completed!"<<std::endl;
    return 0;                                      //(2)返回值
} 

2. 本段代码执行完毕后，输出什么结果？

#include <iostream> 
using namespace std;

#pragma pack (push,4)

typedef struct TagEntityType
{

unsigned char entityknd:4;

unsigned char domain:6;

unsigned char country:6;

unsigned int category;

unsigned char subCategory;

unsigned int specific;

unsigned char extra;

}TEntityType;

#pragma pack (pop)

int  main()
{
    TEntityType et;
    std::cout << sizeof(et) << std::endl;
    return 0;
}

12

字节对齐

注意：位域必须存储在同种数据类型所占的字节中，不能跨两个同种数据类型所占的字节数。也就是说，后面的数字不能大于前面类型的位数。

位域不会影响 sizeof() 的规则

3. 本段代码可能导致什么问题？

#include <iostream> 
using namespace std;


void profess(char* dst, char* src, unsigned int length)
{}

int main()
{
    srand ((unsigned)time (0));
    for (unsigned int idx =0;idx < 1000000000;idx++)
    {
        unsigned int leng =(unsigned int)(rand()% 100);
        char*srcData =  new char[leng];
        char*dstData =  new char[leng*2];
        profess(dstData,srcData,leng);
        free (srcData);
        free(dstData);

    }
    return 0;
}

解析：

本段代码的问题在于内存泄漏。在每次循环迭代中，srcData 和 dstData 都被分配了内存，但在循环的下一次迭代开始之前，这些内存没有被释放。这会导致随着时间的推移，程序占用的内存不断增加，直到耗尽所有可用内存并崩溃。

为了修复这个问题，您需要在每次循环迭代结束时释放 srcData 和 dstData 所指向的内存。以下是修改后的代码；成对出现；

为什么

正确写法：

#include <iostream> 
using namespace std;

void profess(char* dst, char* src, unsigned int length)
{}

int main()
{
    srand ((unsigned)time (0));
    for (unsigned int idx =0; idx < 100000000; idx++)
    {
        unsigned int leng = (unsigned int)(rand() % 100);
        char* srcData = new char[leng];
        char* dstData = new char[leng * 2];
        profess(dstData, srcData, leng);
        delete[] srcData; // 释放内存
        delete[] dstData; // 释放内存
    }
    return 0;
}

4. 本段代码执行过程中可能导致什么问题？

#include <iostream> 
using namespace std;
void swapData(char** dst,char** src)
{
    *dst =  *src;
}


int main()
{
char* srcData = new char[1024];
char* dstData = new char[1024];
memset (srcData,0x00,1024);
memset (dstData,0xFF,1024);
swapData(&dstData,&srcData);

free(dstData);
free(srcData);
return 0;
}

解析

(1)本段代码的问题在于内存泄漏。在 main 函数中，srcData 和 dstData 是通过 new 运算符动态分配的，但在调用 swapData 函数后，这两个指针都指向了同一块内存地址，即 srcData 指向的内存。即开辟大小一致；可理解为realloc;

随后，当尝试释放 dstData 指向的内存时，由于 dstData 和 srcData 指向的是同一块内存，所以会导致重复释放同一内存块，从而产生未定义行为。

为了修复这个问题，您需要确保在释放内存之前，dstData 和 srcData 指向不同的内存块。

(2)new delete释放内存

（3）memset必须用cstring
正确写法：

#include <iostream> 
#include <cstring>
using namespace std;

void swapData(char** dst, char** src)
{
    char* temp = *dst;
    *dst = *src;
    *src = temp;
}

int main()
{
    char* srcData = new char[1024];
    char* dstData = new char[1024];
    memset(srcData, 0x00, 1024);
    memset(dstData, 0xFF, 1024);
    swapData(&dstData, &srcData);
    
    // 现在 srcData 和 dstData 指向不同的内存块
    delete[] dstData; // 释放 dstData 指向的内存
    delete[] srcData; // 释放 srcData 指向的内存
    return 0;
}