【C/C++笔试练习】this指针的概念、初始化列表、const对象调用、构造和析构函数、继承和组合、重载和多态、虚函数的定义、计算日期到天数转换、幸运的袋子

C/C++笔试练习

选择部分

(1)this指针的概念

  下列有关this指针使用方法的叙述正确的是()

  A. 保证基类保护成员在子类中可以被访问
  B. 保证基类私有成员在子类中可以被访问
  C. 保证基类公有成员在子类中可以被访问
  D. 保证每个对象拥有自己的数据成员,但共享处理这些数据的代码

  答案:D

  this指针是一个在成员函数中隐含的指针,它指向调用对象自身。它主要用于区分静态成员函数和成员函数,以及保证基类成员在派生类中可访问。

  所以this指针和父类子类能否访问没有任何的关系。this指针只确保每个对象有自己的数据成员,同时共享处理这些数据的代码(如果这些代码是保护或公有的)所以答案选D。

  

(2)初始化列表

  有一个类B继承自类A,他们数据成员如下:

class A {
...
privateint a;
};

class B : public A {
...
private:
	int a;

public:
	const int b;
	A &c;
	static const char* d;
	B* e;
}

  则构造函数中,成员变量一定要通过初始化列表来初始化的是____。
  A. a b c
  B. b c e
  C. b c d e
  D. c e
  E. b d
  F. b c

  答案:F

  a: 这是类A和类B都有的私有成员变量,我们可以直接对其进行初始化。

  b: 这是一个类B的私有const类型成员。由于它是const类型的的,所以我们不能在类B的构造函数中直接初始化它。对于const类型的成员变量,我们必须在类的构造函数中的初始化列表来初始化。

  c: 这是一个类B的引用成员。引用一旦被初始化就不能更改,因此必须在构造函数初始化列表中进行初始化。

  d: 这是一个类B的静态成员常量。静态成员在类中只有一个实例,且在所有对象之间共享。静态成员不能在类内进行初始化(const类型除外)。它们通常在类外部进行初始化。

  e: 这是一个类B的指针成员。指针可以在构造函数中通过赋值操作符进行初始化,不一定需要在初始化列表中进行初始化。所以答案选F。

  
  初始化列表:

  (1)每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

  (2)类中包含以下成员,必须放在初始化列表位置进行初始化:

    1.引用成员变量

    2.const成员变量

    3.自定义类型成员(且该类没有默认构造函数时)

  (3)尽量使用初始化列表初始化, 因为不管你是否使用初始化列表,对于自定义类型成员变量,一定会先使用初始化列表初始化。

  (4)成员变量在类中声明次序就是其在初始化列表中的初始化顺序, 与其在初始化列表中的先后次序无关。

  

(3)const对象调用

  下面说法正确的是()

  A. C++已有的任何运算符都可以重载
  B. const对象只能调用const类型成员函数
  C. 构造函数和析构函数都可以是虚函数
  D. 函数重载返回值类型必须相同

  答案:B

  A选项:C++已有的任何运算符都可以重载。这是不正确的。有一些运算符不能被重载: . *   ::   sizeof  ?:  .  这5个运算符不能重载

  B选项:const对象只能调用const类型成员函数。这是正确的。const对象意味着该对象的值不能被改变,因此只能调用不会修改对象状态的成员函数,即const类型成员函数。

  C选项:构造函数和析构函数都可以是虚函数。这是不正确的。构造函数不能是虚函数。虚函数的主要目的是实现动态多态,即允许在派生类中重写基类中的虚函数。然而,构造函数是在对象创建时自动调用的,而对象的创建是在编译时确定的,所以不可能有运行时多态。 因此,构造函数不能被声明为虚函数。

  D选项:函数重载返回值类型必须相同。这是不正确的。函数重载的判断依据是函数的参数列表(参数类型、参数个数、参数顺序),而不是返回值类型。只要函数的参数列表相同,即使返回值类型不同,也可以构成函数重载。所以答案选B。

  

(4)构造和析构函数

  下面说法正确的是()

  A. 一个空类默认一定生成构造函数,拷贝构造函数,赋值操作符,引用操作符,析构函数
  B. 可以有多个析构函数
  C. 析构函数可以为virtual,可以被重载
  D. 类的构造函数如果都不是public访问属性,则类的实例无法创建

  答案:A

  对于A选项,这是正确的。当创建一个空类时,编译器会自动生成默认的构造函数。

  对于B选项,这是不正确的。每个类只能有一个析构函数。

  对于C选项,这是不正确的。析构函数不能被重载。

  对于D选项,这是不正确的。类的构造函数可以是任何访问属性,包括private、protected和public。只是如果类的构造函数是public,那么该类的实例可以在任何地方创建。如果构造函数是private,那么也有单例模式可以创建。

  

(5)继承和组合

  面向对象设计中的继承和组合,下面说法错误的是?()

  A. 继承允许我们覆盖重写父类的实现细节,父类的实现对于子类是可见的,是一种静态复用,也称为白盒复用
  B. 组合的对象不需要关心各自的实现细节,之间的关系是在运行时候才确定的,是一种动态复用,也称为黑盒复用
  C. 优先使用继承,而不是组合,是面向对象设计的第二原则
  D. 继承可以使子类能自动继承父类的接口,但在设计模式中认为这是一种破坏了父类的封装性的表现

  答案:C

  A. 继承是子类继承父类的属性和方法,子类可以重写父类的方法,或者在子类中增加新的方法。这是一种静态复用,因为这种复用是在编译时确定的。 白盒复用意味着子类可以看到父类的实现细节。

  B. 组合是指将不同的对象组合在一起以实现新的功能。 在这种情况下,我们不需要关心每个对象的实现细节,只需要知道它们提供哪些接口和方法。这种复用是在运行时确定的,因此被称为动态复用或黑盒复用。

  C. 面向对象设计的原则之一是优先使用组合而不是继承。使用组合可以提供更大的灵活性,因为你可以将不同的对象组合在一起以实现新的功能,而且这种组合是动态的,可以在运行时改变。

  D. 虽然继承确实使子类能够自动继承父类的接口和方法,但这可能会破坏父类的封装性。在设计模式中,通常更倾向于使用组合而不是继承,以保护对象的封装性并提高灵活性。

  

(6)重载和多态

  关于重载和多态正确的是

  A. 如果父类和子类都有相同的方法,参数个数不同,将子类对象赋给父类后,由于子类继承于父类,所以使用父类指针 调用父类方法时,实际调用的是子类的方法
  B. 选项全部都不正确
  C. 重载和多态在C++面向对象编程中经常用到的方法,都只在实现子类的方法时才会使用
  D.

class A{
	void test(float a){cout<<"1";}
};

class B:public A{
	void test(int b){cout<<"2";}
};

A *a=new A;
B *b=new B;
a=b;
a.test(1.1);
//结果是1

  答案:B

  对于选项A,将子类对象赋给父类后,使用父类指针调用父类方法时,实际调用的是父类的方法,而不是子类的方法(如果子类函数和父类函数构成多态,就可以调用子类的方法了)。

  对于选项C,重载和多态是C++面向对象编程中经常用到的技术。不仅仅只在实现子类的方法时才会使用。

  对于选项D的代码示例,编译器会直接报错,因为a是指向父类的指针,指针不能直接进行.操作。如果可以那就会调用父类中的方法,打印1。

在这里插入图片描述

  

(7)程序分析

  以下程序的输出是()

class Base {
public:
	Base(int j): i(j) {}
	virtual~Base() {}
	void func1() 
	{
		i *= 10;
		func2();
	}

	int getValue() 
	{
		return i;
	}
	
protected:
	virtual void func2() 
	{
		i++;
	}
	
protected:
	int i;
};

class Child: public Base {
public:
	Child(int j): Base(j) {}
	void func1() 
	{
		i *= 100;
		func2();
	}
	
protected:
	void func2() 
	{
		i += 2;
	}
};

int main()
{
	Base * pb = new Child(1);
	pb->func1();
	cout << pb->getValue() << endl; delete pb; 
}

  A. 11
  B. 101
  C. 12
  D. 102

  答案:C

#include <iostream>
using namespace std;

class Base {
public:
	Base(int j) : i(j) {}//1.2调用父类构造函数,初始化i;接着再调用子类构造
	virtual~Base() {}
	void func1()//2.1父类指针调用fun1,因为fun1不构造多态
	{
		i *= 10;//2.2 i*10=10
		func2();//2.3  接着调用fun2(),此时的fun2构成多态
	}

	int getValue()//3.1父类指针调用父类函数,直接返回i
	{return i;}
	
protected:
	virtual void func2(){i++;}
	
protected:
	int i;
};

class Child : public Base {
public:
	Child(int j) : Base(j) {}//1.1先找到子类构造函数,初始化列表  //1.3调用子类构造
	void func1(){i *= 100;func2();}

protected:
	void func2()//2.4 调用fun2() 10+2=12
	{
		i += 2;
	}
};

int main()
{
	Base* pb = new Child(1);//1.先创建子类对象Child(1)和父类指针pb,此时父类指针指向的是子类对象
	pb->func1();//2.父类指针调用fun1()
	cout << pb->getValue() << endl; delete pb;//3.父类指针调用getValue()
}

在这里插入图片描述

  

(8)程序分析

  下面 C++ 代码的运行结果为()

#include<iostream>
#include<string>
using namespace std;
class B0 {
public:
 	virtual void display() {
		cout << "B0::display0" << endl;
	}
};

class B1 :public B0 {
public:
	void display() { 
		cout << "B1::display0" << endl; }
};

class D1 : public B1 {
public:
	void display() {
		cout << "D1::display0" << endl;
	}
};

void fun(B0 ptr) 
{
	ptr.display();
}

int main() 
{
	B0 b0;
	B1 b1;
	D1 d1;
	fun(b0);
	fun(b1);
	fun(d1);
}

  A. B0::display0 B0::display0 B0::display0
  B. B0::display0 B0::display0 D1::display0
  C. B0::display0 B1::display0 D1::display0
  D. B0::display0 B1::display0 B1::display0
  答案:A

class B0 {
public:
	virtual void display() {
		cout << "B0::display0" << endl;
	}
};

//无论这里传的是什么类型,这里都调用父类的ptr函数display()
void fun(B0 ptr){
	ptr.display();
}

int main()
{
	B0 b0;
	B1 b1;
	D1 d1;
	fun(b0);
	fun(b1);
	fun(d1);
}

在这里插入图片描述

  

(9)虚函数的定义

  下列哪种函数可以定义为虚函数()
  A. 构造函数
  B. 析构函数
  C. 内联成员函数
  D. 静态成员函数

  答案:B

  A. 构造函数:构造函数用于创建对象,并初始化对象的成员变量。由于构造函数是在对象创建时自动调用的,所以它不能被声明为虚函数。

  B. 析构函数:将析构函数定义为虚函数的主要目的是确保在派生类对象销毁时,基类的析构函数也会被正确调用。这有助于防止资源泄漏,因为可以在析构函数中释放由基类管理的资源。

  C. 内联成员函数:内联函数是为了提高程序的执行效率,我们将函数的代码直接嵌入到调用处,在编译的时候内联函数会展开,但是在虚标中存放的是函数地址,如果内联函数根据地址展开,就无法找到函数地址。所以内联函数不能是虚函数。

  D. 静态成员函数:静态成员函数不是属于类本身的,不是类的对象,也没有this指针,所以无法被声明为虚函数。

  

(10)程序分析

  下面 C++ 程序的运行结果为()

#include<iostream>
using namespace std;

class A {
public:
	A(const char* s)
	{
		cout << s << endl;
	}
	  ~A() {}
};

class B : virtual public A {
public: 
	B(const char* s1, const char* s2)
		:A(s1)
{
	cout << s2 << endl;
}
};

class C : virtual public A {
public: 
	C(const char* s1, const char* s2)
		:A(s1)
{
	cout << s2 << endl;
}
};

class D : public B, public C {
public: 
	D(const char* s1, const char* s2, const char* s3, const char* s4)
		:B(s1, s2), C(s1, s3), A(s1)
{
	cout << s4 << endl;
}
};

int main()
{
	D* p = new D("class A", "class B", "class C", "class D");
	delete p;
	return 0;
}

  A.
   class A
   class B
   class C
   class D

  B.
   class D
   class B
   class C
   class A

  C.
   class D
   class C
   class B
   class A

  D.
   class A
   class C
   class B
   class D

  答案:A

  在主函数中,创建了一个 D 类的对象,并通过 new 关键字动态分配了内存。在 D 类的构造函数中,首先调用了基类 B 和 C 的构造函数,然后调用了基类 A 的构造函数。因此,程序的输出顺序为基类 A、B、C 和 D 的顺序。

在这里插入图片描述

            

编程题 day14

计算日期到天数转换

计算日期到天数转换

  解题思路:用一个数组存放每月的累积天数 输入的日期天数= 当月的天数 + 当月之前的累积天数 如果包含二月,再去判断是否为闰年,如果是闰年,再加1天即可。

#include<iostream>
using namespace std;

//判断闰年
bool isLeap(int year) 
{
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

//根据年和月获取相应月份的天数
int getDaysByYM(int year, int month) 
{
    int days[13] = {29, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    if (month == 2 && isLeap(year))
        month = 0;
    return days[month];
}

//根据年月日获取相应的这一年的第几天
int getDaysByYMD(int year, int month, int day) 
{
    int days = 0;
    for (int i = 1; i < month; ++i) 
    {
        days += getDaysByYM(year, i);
    }
    days += day;
    return days;
}

int main() 
{
    int year, month, day;
    int days = 0;
    while (cin >> year >> month >> day) {
        days = getDaysByYMD(year, month, day);
        cout << days << endl;
    }
    return 0;
}

  

幸运的袋子

幸运的袋子

  解题思路:每次从全集中选择若干元素(小球)组成子集(袋子)。对于任意两个正整数a,b如果满足 a+b>ab,则必有一个数为1。 可用数论证明:设a=1+x,b=1+y,则1+x+1+y>(1+x)(1+y),—> 1>xy,则x,y必有一个为0,即a,b有一个为1.推广到任意k个正整数,假设a1,a2,…ak,如果不满足给定条件,即和sum小于等于积pi。如果此时再选择一个数b,能使其满足sum+b > pib,则,b必然为1,且为必要非充分条件。反之,如果选择的b>1,则sum+b <= pi*b,即a1,a2,…,ak,b不满足给定条件。

  因此,将球按标号升序排序。每次从小到大选择,当选择到a1,a2,…,ak-1时满足给定条件,而再增加选择ak时不满足条件(ak必然大于等于max(a1,a2,…,ak-1)),继续向后选择更大的数,必然无法满足! 此时不必再继续向后搜索。如果有多个1,即当k=1时,sum(1)>pi(1)不满足,但下一个元素仍为1,则可以满足1+1>1*1, 所以要判断当前ak是否等于1,如果等于1,虽然不能满足,组合的个数不能增加,但是继续向后搜索,仍然有满足条件的可能.对于重复数字,组合只能算一个,要去重。

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

int GetLuckyPacketNum(int n, vector<int>& v, int pos, int sum, int multi) 
{
    int count = 0;
    for (int i = pos; i < n; ++i) 
    {
        sum += v[i];
        multi *= v[i];
        if (sum > multi) 
        {
            count = count + 1 + GetLuckyPacketNum(n, v, i + 1, sum, multi);
        } 
        else if (v[i] ==1) 
        { 
            count += GetLuckyPacketNum(n, v, i + 1, sum, multi);
        } 
        else 
        {
            break; 
        }
        sum -= v[i];
        multi /= v[i]; 
        while (i < n - 1 && v[i] == v[i + 1])
            ++i;
    }
    return count;
}

int main() {
    int n;
    cin >> n;
    vector<int> v(n);
    for (size_t i = 0; i < n; ++i)
        cin >> v[i];
    sort(v.begin(), v.end());
    cout << GetLuckyPacketNum(n, v, 0, 0, 1) << endl;
    return 0;
}
  • 7
    点赞
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鳄鱼麻薯球

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值