【C++】经典且易错的题

1.以下不是double compare(int,int)的重载函数的是( )

A.int compare(double,double)

B.double compare(double,double)

C.double compare(double,int)

D.int compare(int,int)

A.重载必须是参数列表有所不同(包括个数和类型)，所以参数类型不同，构成重载 B.参数类型不同，构成重载 C.参数类型不同，构成重载

D.函数重载不能依靠返回值的不同来构成重载，因为调用时无法根据参数列表确定调用哪个重载函数，故错误

2.关于c++的inline关键字,以下说法正确的是( )

A.使用inline关键字的函数会被编译器在调用处展开

B.头文件中可以包含inline函数的声明

C.可以在同一个项目的不同源文件内定义函数名相同但实现不同的inline函数

D.递归函数也都可以成为inline函数

A.不一定，因为inline只是一种建议，需要看此函数是否能够成为内联函数

B. inline函数不支持声明和定义分离开，因为编译器一旦将一个函数作为内联函数处理，就会在调用位置展开，即该函数是没有地址的，也不能在其他源文件中调用，故一般都是直接在源文件中定义内联函数的

C.inline函数会在调用的地方展开，所以符号表中不会有inline函数的符号名，不存在链接冲突。

D.比较长的函数，递归函数就算定义为inline，也会被编译器忽略，故错误

3.下面描述错误的是( )

A.this指针是非静态成员函数的隐含形参.

B.每个非静态的成员函数都有一个this指针.

C.this指针是存在对象里面的.

D.this指针可以为空

A.静态成员函数没有this指针，只有非静态成员函数才有，且为隐藏指针

B.非静态成员函数的第一个参数就是隐藏的this指针

C.对象的内存布局只包含非静态成员变量（以及可能的虚函数表指针等），不包含成员函数代码，也不包含 this 指针，故错误。

补充：成员函数是代码段中的公共代码，同一个类的所有对象共享同一份函数体。this 指针的作用是在函数执行时，告诉函数当前操作的是哪个对象的成员变量。

D.单纯的对this赋空是不可以的，不过可以强转直接赋空，不过一般不进行这样的操作

4.设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？（）

cpp 复制代码

C c;
int main()
{
	A a;
	B b;
	static D d;
  return 0；
}

A.D B A C

B.B A D C

C.C D B A

D.A B D C

分析:1、类的析构函数调用一般按照构造函数调用的相反顺序进行调用，但是要注意static对象的存在，因为static改变了对象的生存作用域，需要等待程序结束时才会析构释放对象

2、全局对象先于局部对象进行构造

3、局部对象按照出现的顺序进行构造，无论是否为static

4、所以构造的顺序为 c a b d

5、析构的顺序按照构造的相反顺序析构，只需注意static改变对象的生存作用域之后，会放在局部对象之后进行析构

6、因此析构顺序为B A D C

5.变量所在哪个内存区域以及变量所占空间大小是多少？（32位）

cpp 复制代码

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
	static int staticVar = 1;
	int localVar = 1;
	int num1[10] = {1, 2, 3, 4};
	char char2[] = "abcd";
	const char* pChar3 = "abcd";
	int* ptr1 = (int*)malloc(sizeof (int)*4);
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int)*4);
	free (ptr1);
	free (ptr3);
}

选择题：

选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)

globalVar在哪里？____ staticGlobalVar在哪里？____

staticVar在哪里？____ localVar在哪里？____

num1 在哪里？____

char2在哪里？____ *char2在哪里？___

pChar3在哪里？____ *pChar3在哪里？____

ptr1在哪里？____ *ptr1在哪里？____

填空题：

sizeof(num1) = ____;

sizeof(char2) = ____; strlen(char2) = ____;

sizeof(pChar3) = ____; strlen(pChar3) = ____;

sizeof(ptr1) = ____;

选择题：

globalVar在哪里？C staticGlobalVar在哪里？C

staticVar在哪里？C localVar在哪里？A

num1 在哪里？A

分析:

globalVar全局变量在数据段 staticGlobalVar静态全局变量在静态区

staticVar静态局部变量在静态区 localVar局部变量在栈区

num1局部变量在栈区

char2在哪里？A *char2在哪里？A

pChar3在哪里？A *pChar3在哪里？D

ptr1在哪里？A *ptr1在哪里？B

分析: char2局部变量在栈区 char2是一个数组，把后面常量串拷贝过来到数组中，数组在栈上，所以*char2在栈上

pChar3局部变量在栈区 *pChar3得到的是字符串常量字符在代码段 ptr1局部变量在栈区

*ptr1得到的是动态申请空间的数据在堆区

填空题：

sizeof(num1) = 40 ;//数组大小,10个整形数据一共40字节

sizeof(char2) = 5 ;//包括\0的空间

strlen(char2) = 4 ;//不包括\0的长度

sizeof(pChar3) = 4 ;//pChar3为指针

strlen(pChar3) = 4 ;//字符串"abcd"的长度，不包括\0的长度

sizeof(ptr1) = 4;//ptr1是指针

6.下面有关c++内存分配堆栈说法错误的是( )

A.对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制

B. 对于栈来讲，生长方向是向下的，也就是向着内存地址减小的方向；对于堆来讲，它的生长方向是向上的，是向着内存地址增加的方向增长

C.对于堆来讲，频繁的 new/delete 势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题

D.一般来讲在 32 位系统下，堆内存可以达到4G的空间，但是对于栈来讲，一般都是有一定的空间大小的

A.栈区主要存在局部变量和函数参数，其空间的管理由编译器自动完成，无需手动控制，堆区是自己申请的空间，在不需要时需要手动释放

B.栈区先定义的变量放到栈底，地址高，后定义的变量放到栈顶，地址低，因此是向下生长的，堆区则相反

C.频繁的申请空间和释放空间，容易造成内存碎片，甚至内存泄漏，栈区由于是自动管理，不存在此问题

D.32位系统下，最大的访问内存空间为4G,所以不可能把所有的内存空间当做堆内存使用，故错误

7.C++中关于堆和栈的说法，哪个是错误的:( )

A.堆的大小仅受操作系统的限制，栈的大小一般较小

B.在堆上频繁的调用new/delete容易产生内存碎片，栈没有这个问题

C.堆和栈都可以静态分配

D.堆和栈都可以动态分配

A.堆大小受限于操作系统，而栈空间一般有系统直接分配

B.频繁的申请空间和释放空间，容易造成内存碎片，甚至内存泄漏，栈区由于是自动管理，不存在此问题

C.堆无法静态分配，只能动态分配

D.栈可以通过函数_alloca进行动态分配，不过注意，所分配空间不能通过free或delete进行释放

cpp 复制代码

ClassA *pclassa=new ClassA[5];
delete pclassa;

c++语言中，类ClassA的构造函数和析构函数的执行次数分别为( )

A.5,1

B.1,1

C.5,5

D.程序可能崩溃

A.申请对象数组，会调用构造函数5次，delete由于没有使用[]，此时只会调用一次析构函数，但往往会引发程序崩溃

B.构造函数会调用5次

C.析构函数此时只会调用1次，要想完整释放数组空间，需要使用[]

D.正确

9.函数参数使用的空间是在（）中申请的，malloc或new是在（）中申请空间的？（）

A.堆，栈

B.栈，堆

C.栈，栈

D.堆，堆

参数在栈空间存放，malloc或new申请的空间为堆区

10.设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？（）

cpp 复制代码

C c;
void main()
{
  A*pa=new A();
  B b;
  static D d;
  delete pa;
}

A.A B C D

B.A B D C

C.A C D B

D.A C B D

首先手动释放pa，所以会先调用A的析构函数，其次会跟定义相反的顺序释放局部对象，这里只有b，就释放b，再释放静态局部对象d，再释放全局对象c

11.使用 char* p = new char[100]申请一段内存，然后使用delete p释放，有什么问题？( )

A.会有内存泄露

B.不会有内存泄露，但不建议用

C.编译就会报错，必须使用delete []p

D.编译没问题，运行会直接崩溃

A.对于内置类型，此时delete就相当于free，因此不会造成内存泄漏

B.正确

C.编译不会报错，建议针对数组释放使用delete[],如果是自定义类型，不使用方括号就会运行时错误

D.对于内置类型，程序不会崩溃，但不建议这样使用

12.计算一年中的第几天
题目链接

cpp 复制代码

//第一种
#include<iostream>
using namespace std;
/*
*思路：
* 1. 通过枚举每个月的1号是这一年的第几天，从而进行累加求和即可，其中注意闰年的处理
*/
int main()
{
  int year, month, day;
  while(cin>>year>>month>>day)
  {
    int monthDays[13] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
    int nday = monthDays[month-1] + day;
    if(month > 2 &&((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
    {
      nday += 1;
    }
    cout<<nday<<endl;
  }
 return 0;
}

cpp 复制代码

//第二种
#include<iostream>
using namespace std;
bool IsLeapYear(int y) {
    return ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0));
}
int main() {
    int y, m, d;

    while (cin >> y >> m >> d) {
        int day = 0;
        int MonthDay[13] = { -1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        if (IsLeapYear(y))
            MonthDay[2] = 29;
        for (int i = 1; i < m; i++) {
            day += MonthDay[i];
        }
        cout << day + d << endl;
    }

    return 0;
}

13.日期差值
题目链接

cpp 复制代码

#include <iostream>
using namespace std;
  /*
  *思路：
  * 1. 分别求出每一个日期与0000年0月1日距离的天数
  * 2. 两个距离天数相减即可得到两个日期相差的天数
  */
  //平年从1月到n月的天数
  int mon[12]={0,31,59,90,120,151,181,212,243,273,304,334};
  //给出年月日，计算距离0000年0月1日的天数和
  int CountDay(int y,int m,int d)
  {
    // 计算0-y年的天数
    int yearDay = y*365+y/4-y/100+y/400;
    // 计算到0-m月的天数
    int monthDay = mon[m-1];
    if(m > 2 && ((y%4 == 0 && y%100 != 0) || y%400==0))
     	monthDay += 1;
    return yearDay + monthDay + d;
  }
  int main()
  {
    int year1,month1,day1;
    scanf("%4d%2d%2d",&year1,&month1,&day1);
    int n1 = CountDay(year1,month1,day1);
    int year2,month2,day2;
    scanf("%4d%2d%2d",&year2,&month2,&day2);
    int n2 = CountDay(year2,month2,day2);  
    cout<<abs(n1-n2)+1<<endl;
  }