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

C/C++笔试练习

选择部分

（1）this指针的概念

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

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

  答案：D

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

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

（2）初始化列表

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

class A {
...
private：
	int 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-&gt;getValue() << endl; delete pb; 
}

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

  答案：C

#include <iostream&gt;
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-&gt;func1();//2.父类指针调用fun1()
	cout << pb-&gt;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 &amp;&amp; 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 &amp;&amp; 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>&amp; 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 &amp;&amp; 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;
}

代码007普通

打赏 收藏 海报 链接