【C/C++笔试练习】引用和指针的区别、析构函数的特征、运算符重载、类和对象的描述、this指针的概念、堆和栈的区别、二进制插入、查找组成一个偶数最接近的两个素数

C/C++笔试练习

选择部分

（1）引用和指针的区别

  引用和指针，下面说法不正确的是（）

  A. 引用和指针在声明后都有自己的内存空间
  B. 引用必须在声明时初始化，而指针不用
  C. 引用声明后，引用的对象不可改变，对象的值可以改变，非const指针可以随时改变指向的对象以及对象的值
  D. 空值NULL不能引用，而指针可以指向NULL

  答案：A

  A. 引用和指针在声明后都有自己的内存空间 - 这是不正确的。引用可以理解为给变量取别名：引用在声明后立即与一个已存在的变量关联，它不是一个新的内存空间，而是已存在变量的别名。而指针在声明后确实有自己的内存空间，这个内存空间存储的是指向其他变量的地址。

  B. 引用必须在声明时初始化，而指针不用 - 这是正确的。引用必须在声明时初始化，并且一旦初始化后就不能再改变。而指针在声明后可以指向任何地址，包括NULL。

  C. 引用声明后，引用的对象不可改变，对象的值可以改变，非const指针可以随时改变指向的对象以及对象的值 - 这是正确的。引用一旦与一个对象关联后，就不能再与另一个对象关联；但是原对象的值是可以改变的。非const指针可以随时改变指向的对象以及对象的值。

  D. 空值NULL不能引用，而指针可以指向NULL - 这是正确的。试图使用空值NULL来初始化引用是不允许的，但是指针可以指向NULL。 所以答案选A。

  

（2）析构函数的特征

  下列哪一个是析构函数的特征（）

  A. 析构函数定义只能在类体内
  B. 一个类中只能定义一个析构函数
  C. 析构函数名与类名不同
  D. 析构函数可以有一个或多个参数

  答案：B

  析构函数是一个特殊的成员函数，它用于释放类在生命周期中分配的资源。

  （1）析构函数在类中声明和定义。

  （2）一个类只能有一个析构函数。

  （3）析构函数名与类名相同。

  （4）析构函数没有返回值和参数。

  

（3）运算符重载

  若要对data类中重载的加法运算符成员函数进行声明，下列选项中正确的是？

  A. Data operator+(Data);
  B. Data operator(Data);
  C. operator+(Data,Data);
  D. Data+(Data);

  答案：A

  C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

  函数名字为：关键字operator后面接需要重载的运算符符号。

  函数原型：返回值类型 operator操作符(参数列表)

  注意：

  （1）不能通过连接其他符号来创建新的操作符：比如operator@ 。

  （2）重载操作符必须有一个类类型参数。

  （3）用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义。

  （4）作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this。

   （5） . *   ::   sizeof  ?:  .  注意以上5个运算符不能重载。

  
  A. Data operator+(Data);这个选项是正确的。它是在类的内部定义了一个名为operator+的成员函数，该函数返回类型为Data，并且接受一个类型为Data的参数。

  B. Data operator(Data);这个选项是错误的。运算符重载函数的声明缺少了运算符的名称（如+、-、*等）。

  C. operator+(Data,Data);这个选项也是错误的。虽然它使用了运算符的名称，但它没有将返回类型指定为Data，而是使用了不正确的语法。

  D. Data+(Data);这个选项错误的明显。所以答案选A。

  

（4）调用构造函数次数

  若MyClass是一个类名，其有如下语句序列：

MyClass c1，*c2；
MyClass *c3=new MyClass；
MyClass &c4=c1；

  上面的语句序列调用构造函数个数是( )。

  A. 1
  B. 2
  C. 3
  D. 4

  答案：B

  MyClass c1，*c2；代码先创建了MyClass对象c1和MyClass*类型c2，这里的c1是MyClass对象，所以调用一次构造函数，但是c2的类型是指针，所以不需要调用构造函数。

  MyClass *c3=new MyClass；这里创建了一个MyClass类型指针c3指向一个MyClass对象，所以还是需要调用一次构造函数去创建这个new的对象。

  MyClass &c4=c1；这里的c4和c2是一样的道理，都是指针，不需要创建对象，调用构造函数。

  

（5）类和对象的描述

  下面关于类和对象的描述中，错误的是：

  A. 类就是C语言中的结构体类型，对象就是C语言中的结构体变量
  B. 类和对象之间的关系是抽象和具体的关系
  C. 对象是类的实例，一个对象必须属于一个已知的类
  D. 类是具有共同行为的若干对象的统一描述体

  答案：A

  A选项错误，类和对象是面向对象编程中的基本概念。类是一种抽象的数据类型，它定义了对象的属性和方法，对象是类的实例。C语言中的结构体类似于类，但并不完全等同。

  B选项正确，类是对象的抽象，对象是类的具体实例。

  C选项正确，每个对象都属于一个具体的类，类定义了对象的属性和方法，对象是类的实例。

  D选项正确，类是对象的抽象描述，它定义了一组具有相同属性和方法的对象。所以答案选A。

  

（6）类和对象的描述

  下列关于类和对象的叙述中，错误的是（）

  A. 一个类只能有一个对象
  B. 对象是类的具体实例
  C. 类是对某一类对象的抽象
  D. 类和对象的关系是一种数据类型与变量的关系

  答案：A

  A选项错误，一个类可以创建多个对象。类和对象就像房子和房子图纸一样，房子的图纸只有一张，但是一张图纸可以建造出多个房子。

  B选项正确，对象是类的实例。

  C选项正确，类是对某一类对象的抽象，描述了这类对象的共同属性和方法。

  D选项正确，类和对象的关系可以看作是一种数据类型与变量的关系。所以答案选A。

  

（7）代码分析

  如果有一个类是 myClass , 关于下面代码正确描述的是:

myClass::~myClass(){
	delete this;
	this = NULL;
}

  A. 正确，我们避免了内存泄漏
  B. 它会导致栈溢出
  C. 无法编译通过
  D. 这是不正确的，它没有释放任何成员变量。

  答案：C

  这里试图在 myClass 类的析构函数中删除类实例本身，并将实例指针设置为 NULL。但是这种做法是不正确的。我们不能在析构函数中detele this，因此这段代码将无法编译通过。所以答案选C。

  

（8）构造函数的概念

  请问以下说法，哪个是正确的：

  A. 每个类都有一个无参数的构造函数。
  B. 每个类都有一个拷贝构造的函数。
  C. 每个类能有多个构造函数。
  D. 每个类能有多个析构函数。

  答案：C

  A. 每个类都有一个无参数的构造函数 - 这是不正确的。类可以有一个无参数的构造函数，我们称之为默认构造函数。

  B. 每个类都有一个拷贝构造的函数 - 这也是不正确的。拷贝构造函数是一种特殊类型的构造函数，它用于创建一个新对象，该对象的内容是现有对象的副本。 但是，类可以有拷贝构造函数，也可以没有。

  C. 每个类能有多个构造函数 - 这是正确的。类可以有多个构造函数，每个构造函数可以有不同的参数列表。

  D. 每个类能有多个析构函数 - 这是不正确的。类只能有一个析构函数。 所以答案选C。

  

（9）this指针的概念

  下面程序段包含4个函数,其中具有隐含this指针的是（）

int f1();
class T
{
	public:static int f2();
	private:friend int f3();
	protect:int f4();
};

  A. f1
  B. f2
  C. f3
  D. f4

  答案：D

  类中的每个非静态成员函数中都有一个隐藏的this指针。

  A.int f1();是一个全局函数，它不具有隐含的this指针。

  B.public:static int f2();是一个静态成员函数，它不具有隐含的this指针。

  C.private:friend int f3();是一个友元函数，它也不具有隐含的this指针。

  D.protect:int f4();是一个保护成员函数，它具有隐含的this指针。

  

（10）堆和栈的区别

  C++中关于堆和栈的说法，哪个是错误的（）

  A. 堆的大小仅受操作系统的限制，栈的大小一般较小
  B. 在堆上频繁的调用new/delete容易产生内存碎片，栈没有这个问题
  C. 堆和栈都可以静态分配
  D. 堆和栈都可以动态分配

  答案：C

  A选项正确，堆的大小通常受操作系统的限制，具体取决于系统为进程分配的虚拟内存空间。栈的大小通常较小，它用于存储局部变量和函数调用的信息。

  B选项正确，在堆上频繁调用new/delete操作可能会导致内存碎片问题，因为这些操作可能会导致内存空间的非连续分配。相比之下，栈没有这个问题，因为它是连续的内存区域。

  C选项错误，堆不可以静态分配，而栈可以静态分配。静态分配是在编译时确定内存的大小和位置，而堆的内存分配是在运行时决定的。

  D选项正确，堆和栈都可以动态分配。在C++中，使用new操作符在堆上动态分配内存，使用malloc函数也可以实现动态分配（尽管它通常用于C语言）。栈的动态分配是通过函数调用实现的，函数调用时会在栈上为其分配内存空间。所以答案选C。

            

编程题 day12

二进制插入

二进制插入

  i j m:1024：100000000 00 n:19 ： 10011 要把n的二进制值插入m的第j位到第i位，只需要把n先左移j位，然后再进行或运算（|）即可。

  m: 10000000000
  n: 00001001100
  10001001100

class BinInsert {
  public:
    int binInsert(int n, int m, int j, int i) 
    {
        m <<= j;
        return n | m;
    }
};

  

查找组成一个偶数最接近的两个素数

查找组成一个偶数最接近的两个素数

  本题首先需要判断素数，素数表示除过1和本身，不能被其它数整除。通过循环遍历来判断一个数是否为素数。最近的两个素数应该从最中间的位置开始向两边查找。

#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;

//判断素数
bool isPrime(int num) 
{
    int tmp = sqrt(num);
    //只遍历到开方出，不能被开方左边的数整除，则一定不能被开方右边的数整除
    for (int i = 2; i <= tmp; i++) 
    {
        if (num % i == 0)
            return false;
    }
    return true;
}

int main() 
{
    int num;
    int half;
    int i;
    while (cin >> num) 
    {
        half = num / 2;
        //从中间向两边找
        for (i = half; i > 0; i--) {
            if (isPrime(i) && isPrime(num - i))
                break;
        }
        cout << i << endl << num - i << endl;
    }
    return 0;
}