C++ 面试题型总结

本是古典何须时尚 2023-06-07 05:37 9阅读 0赞

### 1. 常量指针 ###

const char * p;  // 字符是常量，指针 p 可以改变，指向的常量值不能改变
    char const *p;  // 同上
    char* const p;  // 指针p 是常量， 不能改变指针的值

### 2. 字符数组变量有各自的内存空间，指针指向相同的区域 ###

char str1[] = "abc";
    char str2[] = "abc";
    
    const char str3[] = "abc";
    const char str4[] = "abc";
    
    char* str5 = "abc";
    char* str6 = "abc";
    
    const char* str7 = "abc";
    const char* str8 = "abc";
    
    
    std::cout << (str1 == str2) << std::endl;  // 0
    std::cout << (str3 == str4) << std::endl;  // 0
    std::cout << (str5 == str6) << std::endl;  // 1
    std::cout << (str7 == str8) << std::endl;  // 1

### 3. 函数中字符串数组的大小 sizeof ###

void testChar(char str[]){
        cout << sizeof(str) << endl;  // 4
        cout << strlen(str) << endl;  // 11
    }
    
    char str[] = "ahkadkgjsal";
    testChar(str);  // str 在函数中是以指针形式保存，为 4 个字节
    
    cout << sizeof(str) << endl;  // 12

### 4. &a + 1 偏移1 个数组的大小 ###

int main(){
        int a[5] = {1, 2, 3, 4, 5};
        int* ptr = (int*)(&a + 1);
        cout << *(ptr-1) << endl;  // 5
    }

\*(a+1）就是a\[1\]，\*(ptr-1)就是a\[4\],执行结果是2，5  
**&a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int）**  
int \*ptr=(int \*)(&a+1);  
则ptr实际是&(a\[5\]),也就是 a+5

### 5.下列代码存在的问题 ###

int  main()
    {
    
    char a;
    char *str=&a;
    strcpy(str,”hello”);
    printf(str);
    
    return 0;
    
    }

没有为str分配内存空间，将会发生异常。问题出在**将一个字符串复制进一个字符变量指针所指地址**。vs报错。

### 6.代码问题 ###

char* s="AAA";   // ”AAA” 是字符串常量， 修改为：  const chat* s = "AAA";
    printf(“%s”,s);
    s[0]=’B';   //  由于是常量，不能对其进行赋值
    printf(“%s”,s);

### 7. int (\*s\[10\])(int) 表示 ###

函数指针数组， 每一个指针指向 int function(int param) 函数

char (*str) [10];  // *str 是一个数组指针，指向数组的指针
    char *str[10];     // *str 是一个指针数组，存放的所有的元素都是指针

### 8.sizeof() 和字符数组初始化没有关系； strlen（） 与初始化相关； ###

char s[10];
    cout << sizeof(s) << endl;  // 10
    cout << strlen(s) << endl;  // 25  随意的一个值

### 9. 下列代码的错误 ###

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

**存在2处问题：**

**1. 未对malloc的内存进行释放**

**2. 未判断内存是否申请成功；**

void GetMemory(char **p,int num)
    {                          
    //p，指向指针的指针，*p，p指向的指针(即str)，**p，最终的对象，str指向的单元
    
    *p=(char *)malloc(num);  //申请空间首地址付给传入的被p指向的指针，即str
    if (*p == NULL){
        cout <<" 申请内存失败"  << endl;  // 2. 判断内存是否申请失败
    } 
    
    }
    
    int main()
    {
    char *str=NULL;
    GetMemory(&str,100);   //传入指针变量本身的地址
    strcpy(str,”hello”);
    free(str);  //1.  释放内存
    str = NULL;
    }

### 10. 下列代码的不足 ###

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

1. 没有对内存是否申请成功进行判断

2， free(str) 后没有置 str 为空，导致可能变成一个野指针

void Test( void )
    
    {
    
    　char *str = (char *) malloc( 100 );
      
      if (str == NULL){
            cout << "内存申请失败"  << endl;
            return;
    }
    
    　strcpy( str, "hello" );
    
    　free( str );
      str = NULL;
    
    　... //省略的其它语句
    
    }

### 11. 两个数字交换 ###

void swap1(int* p1, int* p2){  // 存在问题
        int* temp;  //  新建1 个指针，但是没有分配内存，temp= p1 是指向而不是拷贝
        temp = p1;
        p1 = p2;
        p2 = temp;
    }
    
    void swap2(int* p1, int* p2){  // 指针传递
        int temp;
        temp = *p1;
        *p1 = *p2;
        *p2 = temp;
    }
    
    void swap3(int &p1,int &p2){  // 引用传递
        int temp;
        temp = p1;
        p1 = p2;
        p2 = temp;
    }
    
    void swap4(int *p1, int* p2){
        int *temp;
        *temp = *p1;
        *p1 = *p2;
        *p2 = *temp;
    }
    int *temp新建了一个指针（但是没分配内存）。*temp=*p不是指向而是拷贝。
    把*p所指向的内存的值（也就是a 的值）拷贝到*temp所指向内存里了。
    但是int *temp不是不分配内存吗？的确不分配，于是系统在拷贝时临时给了一个随机地址，让它存值。
    分配的随机地址是个“意外”，且函数结束后不回收，造成内存泄漏。

### 12. char str\[\] 和 char\* str 区别 ###

char* strA(){
        char str[] = "hello world";
        return str;
    }
    //  str[]  是局部变量， 对应内存中的栈，局部变量在声明周期结束后该变量就不存在了。返回结果不正确
    
    
    const char* strB(){
        const char* str = "hello world";
        return str;
    }
    // 指向常量区的字符串，位于静态存储区，它在程序中声明周期不变，返回结果正确

修改第一个程序: 使用static 开辟一段静态的存储空间

char* strA(){
        static char str[] = "hello world";
        return str;
    }

### 13. 判断程序运行结果的输出 ###

int arr[] = {1,2,3,4,5,6,7,8}; // 定义 1 个数组
    
    int *p=arr;
    
    *(p++)+=123;  
         
    printf("%d,%d\n", *p,*(++p));

第三行，p++里的 **++ 是最后才运算**，所以先执行\*p+=123，也就是arr的第0个元素被赋值为 124  
此时arr变成\{123,2,3,4,5,6,7,8\} ，然后是p++，**此时 \*p 已经是等于arr的第1个元素了，也就是2**  
第四行，**在执行printf时，括号里的参数是从右往左的顺序进行读取的**，也就是说先执行 \*(++p)，也就是p先加一再指针，指向的是arr第2个元素3，然后在执行\*p，还是3  
最后显示的内容就是  
**3,3**

###    14.输出结果 ###

unsigned char* p1;
    unsigned long* p2;
    p1 = (unsigned char*)0x801000;
    p2 = (unsigned long*)0x810000;
    p1 + 5= ???
    p2 + 5 = ???

p1 相当于加上 5 位， 0x801005 (十六进制)

p2 相当于加上 5 \*4 = 20 位， 0x810014

### 15. 找出下列代码的错误 ###

将字符串倒序输出

#include"string.h" 　　
    
    main() 　　
    { 　　
    char*src="hello,world"; 　
    char* dest=NULL; 　　
    int len=strlen(src); 　　
    dest=(char*)malloc(len); 　　   
    char* d=dest; 　　
    char* s=src[len]; 　         
    while(len--!=0) 　　
        d++=s--; 　　       
    printf("%s",dest); 　　
    return 0; 　　
    }

**程序有4 个错误的地方**

int main() 　　
    
    { 　　
    　const char* src = "hello,world"; 　　
    　int len = strlen(src); 　　
    
    　char* dest = (char*)malloc(len+1);// 1. 要为 分配一个内存空间 ，+1 存放'\0'　　　
      char* d = dest; 　　// 作为移动的指针
    　const char* s = &src[len-1];          // 2. 指向最后一个字符　　
    　while( len-- != 0 ) 　　
    
    　     *d++=*s--;  // 赋值操作　　
    
    　*d = '\0';           //3.尾部要加’\0’ 　　
    
    　printf("%sn",dest); 　　　
    
    free(dest);        // 4. 使用完，应当释放空间，以免造成内存汇泄露
    dest = NULL;　　 //防止产生野指针　
    
    return 0; 　
    　}

### 16.程序的内存分配： ###

**1、栈区（stack）**—由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。  
**2、堆区（heap）**—一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。  
**3、全局区（静态区）（static）**—全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。  
**4、文字常量区**— **常量字符串**就是放在这里的。程序结束后由系统释放。  
**5、程序代码区**—存放函数体的二进制代码

int a=0;  //全局初始化区
    char *p1; //全局未初始化区
    main()
    {
    int　b;          // 栈
    char s[]=”abc”; // 栈
    char *p2;       // 栈
    char *p3=”123456″; //  123456\0在常量区， p3在栈上。
    static int c=0； //  全局（静态）初始化区
    p1 = (char*)malloc(10);
    p2 = (char*)malloc(20); //  分配得来得10和20字节的区域就在堆区。
    strcpy(p1,”123456″);    //  123456\0放在常量区，编译器可能会将它与p3所向”123456″优化成一个地方。
    }

### 17.根据要求定义 ###

a) 一个整型数 （An integer）  
b) 一个指向整型数的指针 （A pointer to an integer）  
c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）  
d) 一个有10个整型数的数组（An array of 10 integers）  
e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers）  
f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers）  
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）  
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数

（ An array of ten pointers to functions that take an integer argument and return an integer ）  
  
答案是：  
a) int a; // An integer  
b) int \*a; // A pointer to an integer  
c) int \*\*a; // A pointer to a pointer to an integer  
d) int a\[10\]; // An array of 10 integers  
e) int \*a\[10\]; // An array of 10 pointers to integers  
f) int (\*a)\[10\]; // A pointer to an array of 10 integers  
g) int (\*a)(int); // A pointer to a function a that takes an integer argument and returns an integer  
h) int (\*a\[10\])(int); // An array of 10 pointers to functions that take an integer argument and return an integer

### 18.代码输出的值： ###

void foo()
    {
    	unsigned int a = 6;
    	int b = -20;
    	(a + b > 6) ? puts(" > 6 ") : puts("< 6 ");  //  > 6 
    	cout << (a + b) << endl; // 4294967282
    }

**C语言中的整数自动转换原则**，这无符号整型问题的答案是输出是 ">6″。原因是当表达式中**存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。， 所有 -20 会转换成一个非常大的数字**

### 19评价代码 ###

unsigned int zero = 0;
    unsigned int compzero = 0xFFFF;

**对于一个int型不是16位的处理器为说，上面的代码是不正确的。应编写如下：  
unsigned int compzero = ~0;**

说明：~是位运算符，是取反的意思,即二进制位0变1,1变0；  
unsigned int compzero = 0xFFFF;表示1111 1111 1111 1111，对于int型不是16位的处理器来说，上面的代码是不正确的。  
unsigned int compzero=~0;（以16位处理器来说明）表示将0的二进制位0000000000000000取反，变成1111111111111111，对不是16位处理器的也是正确的。

### 20.代码执行结果： ###

int a = 5, b = 7, c;
    c = a+++b;

**代码执行为： c = a++ + b; // 先执行 a++**

**输出为： a =,6; n = 7; c = 12**

### 21.输出结果 ###

typedef union {long i; int k[5]; char c;} DATE;
    struct data { int cat; DATE cow; double dog;} too;
    DATE max;
    则语句 printf(“%d”,sizeof(struct date)+sizeof(max));的执行结果是？

答 、结果是：52。DATE是一个union, 变量公用空间. 里面最大的变量类型是int\[5\], 占用20个字节. 所以它的大小是20  
data是一个struct, 每个变量分开占用空间. 依次为int4 + DATE20 + double8 = 32.  
所以结果是 20 + 32 = 52.  
当然…在某些16位编辑器下, int可能是2字节,那么结果是 int2 + DATE10 + double8 = 20

### 22，问函数既然不会被其它函数调用，为什么要返回1？ ###

int main()  
\{  
int x=3;  
printf(“%d”,x);  
return 1;  
\}  
答：**mian中，c标准认为0表示成功，非0表示错误。具体的值是某中具体出错信息**

### 23.结果输出 ###

unsigned short A = 10;
    	printf("~A = % u\n", ~A); // 4294967282 
    
    	char c = 128;
    	printf("c = % d\n", c); // -128

第一题，～A ＝0xfffffff5 ,**int 值 为－11，但输出的是uint**。所以输出4294967285  
第二题，c＝0×10,**输出的是int**，最高位为1，是负数，所以它的值就是0×00的补码就是128，所以输出－128。  
这两道题都是在考察二进制向int或uint转换时的最高位处理。

### 24.long a=0×801010;a+5=?   答：0×801010用二进制表示为：“1000 0000 0001 0000 0001 0000”，十进制的值为8392720，再加上5就是8392725 ###

### 25.结构体的大小 ###

**偏移量指的是结构体变量中成员的地址和结构体变量地址的差。**

**结构体大小等于最后一个成员的偏移量加上最后一个成员的大小。**

（1）结构体变量中成员的偏移量必须是成员大小的整数倍（0被认为是任何数的整数倍）

（2）结构体大小必须是所有成员大小的整数倍，也即所有成员大小的公倍数。

struct stru{
    	char a;   //第一个成员a的偏移量为0
    	int b;    //第二个成员b的偏移量是第一个成员的偏移量加上第一个成员的大小（0+1=1，但是必须是第二个变量类型长度4的倍数，即为4）
    	float c;  //第三个成员c的偏移量是第二个成员的偏移量加上第二个成员的大小（4+4=8，但是必须是第三个变量类型长度4的倍数，即为8）
    	double d; //第四个成员d的偏移量是第三个成员的偏移量加上第三个成员的大小（8+4=12，但是必须是第四个变量类型长度8的倍数，即为16）  
    };
    //最后计算结构体大小等于最后一个成员（第四个）的偏移量（16）加上最后一个成员的大小（8）。
    //即16+8(double)=24
    //另外结构体大小必须是所有成员大小的整数倍，也即所有成员大小的公倍数。
    //大于等于24并且1,4,4,8的公倍数------>24

struct stru{
    	char a;   //第一个成员a的偏移量为0
    	int b;    //第二个成员b的偏移量是第一个成员的偏移量加上第一个成员的大小（0+1=1，但是必须是第二个变量类型长度4的倍数，即为4）
    	float c;  //第三个成员c的偏移量是第二个成员的偏移量加上第二个成员的大小（4+4=8，是第三个变量类型长度4的倍数，即为8）
    	double d; //第四个成员d的偏移量是第三个成员的偏移量加上第三个成员的大小（8+4=12，但是必须是第四个变量类型长度8的倍数，即为16） 
    	int e;	  //第五个成员e的偏移量是第四个成员的偏移量加上第四个成员的大小（16+8=24，是第五个变量类型长度4的倍数，即为24）  
    };
    //最后计算结构体大小等于最后一个成员（第五个）的偏移量（24）加上最后一个成员的大小（4）。
    //即24+4(double)=28
    //另外结构体大小必须是所有成员大小的整数倍，也即所有成员大小的公倍数。
    //大于等于28并且1,4,4,8,4的公倍数------>32

### 26.宏定义最大值 ###

#define MAX(a, b) ((a) > (b) ? (a): (b))
    
    
    cout << MAX(1.2, 2.4) << endl;

### 27.判断操作系统是32 位还是 64 位 ###

1. 使用库文件：

#include <iostream>
    #include <Windows.h>
    
    using namespace std;
    
    void is64BitOS() {
    	SYSTEM_INFO cur_system_info;
    	GetNativeSystemInfo(&cur_system_info);
    
    	WORD system_str = cur_system_info.wProcessorArchitecture;
    	if (system_str == PROCESSOR_ARCHITECTURE_AMD64 || system_str == PROCESSOR_ARCHITECTURE_IA64) {
    		cout << "this is 64 OS"  << endl;
    	}else cout << "other OS" << endl;	
    	
    }

2. 使用指针判断：指针在32位操作系统时 4个字节，在64位是8个字节

int *p;
    if (sizeof(p) == 4) std::cout << "32位操作系统" << std::endl;
    else cout << "64 位操作系统" << endl;

### 28.判断是大端还是小端的 ###

**大端模式**：数据的低位保存在内存中的高地址中，数据的高位保存在内存中的低地址当中。

**小端模式**：数据的低位保存在内存中的低地址中，数据的高位保存在内存中的高地址当中。

将0x12345678写入到以1000h开始的内存中,这里0x12346578中0x12~0x78的地址是从高到低

如果,我们的机器是小端存储的话,结果为:

数据 地址  
0x78 1000H  
0x56 1001H  
0x34 1002H  
0x12 1003H  
如果我们的机器是大端存储的话,结果为:

数据 地址  
0x12 1000H  
0x34 1001H  
0x56 1002H  
0x78 1003H  
  
https://blog.csdn.net/wang57389675/article/details/52526251

**优势点：**

小端模式：强制转换数据不需要调整字节内容，1、2、4字节的存储方式一样。

大端模式：符号位的判定固定为第一个字节，容易判断正负。

void isBigEndian(){
        int a = 0x12345678;
        char data = *(char *)(&a); // 强制类型转换成char单字节，data 指向a的起始字节（低字节）
        if (data == 0x12) cout << "小端模式" << endl; 
        else cout << "大端模式" << ednl;
    }

### 29.C++ 实现 回调函数 ###

通过一个函数指针调用一个函数

其中：

> **typedef int (\*PFunc)(int); // 定义**
> 
> 去掉typedef int (\*PFunc)(int) 是 一个指向 返回类型为 int， 参数是 int 类型的函数；
> 
> typedef int (\*PFunc)(int); 所以： PFunc是函数指针类型的 别名；
> 
> 类似于 typedef unsigned int uint; 用 unit 代替 unsigned int ;
> 
> **PFunc func； func是一个返回类型为 int ， 参数是int 类型的函数**

typedef int (*PFunc)(int);  // PFunc 是函数指针
    
    int getNum(int n) {
    	return n*10;
    }
    
    int main(){
        
        PFunc multi = getNum;
    	cout << multi(10) << endl;
    
        return 0;
    }

### 项目推荐： ###

**[2000多G的计算机各行业电子资源分享（持续更新）][2000_G]**

**[2020年微信小程序全栈项目之喵喵交友【附课件和源码】][2020]**

**[Spring Boot开发小而美的个人博客【附课件和源码】][Spring Boot]**

**[Java微服务实战296集大型视频-谷粒商城【附代码和课件】][Java_296_-]**

**[Java开发微服务畅购商城实战【全357集大项目】-附代码和课件][Java_357_-]**

**[最全最详细数据结构与算法视频-【附课件和源码】][-]**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]

[2000_G]: https://mp.weixin.qq.com/s/sP4JgGWkCzpgwKr9sAV2_Q
[2020]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487704&idx=1&sn=5f4b2127c4d49fd07ae072a0721424a2&chksm=e8036fc2df74e6d489c4aa9b06f917ef7cee6027f13e150fca53cf79d5d188d4ccc1af49e098&scene=21#wechat_redirect
[Spring Boot]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487798&idx=2&sn=ac0293b996521b872a9dba5fbb3e65e6&chksm=e8036e2cdf74e73aba104a9a994a5b2e31483e8dcbe0f1d9936f6d5173b887e1560f59d2819c&scene=21#wechat_redirect
[Java_296_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487674&idx=1&sn=7aff0bdf2bb727303f3d3618995aef21&chksm=e8036fa0df74e6b6d872c7e6ece179c524ed463a4a6b74c96875475c9a3d5ddb903427dd993b&scene=21#wechat_redirect
[Java_357_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247486376&idx=1&sn=d1fef270c463ea8ac663f6fbfedd70a0&chksm=e80374b2df74fda4d3bafba878a106a19e18c5fcda266008f4f37975847a21bc612ffcd5ff39&scene=21#wechat_redirect
[-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487750&idx=1&sn=747bccbb5f5ea6b58915198de40da777&chksm=e8036e1cdf74e70ae97a5e8e265b49d7236d904d291203309159d07ba1724033062c0e370843&scene=21#wechat_redirect
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]: /images/20230601/d3ef0de814bd42918f8a37e5d2feb1f1.png