文章目录
- C/C++笔试练习
- 选择部分
- （1）this指针的概念
- （2）初始化列表
- （3）const对象调用
- （4）构造和析构函数
- （5）继承和组合
- （6）重载和多态
- （7）程序分析
- （8）程序分析
- （9）虚函数的定义
- （10）程序分析
- 编程题 day14
- 计算日期到天数转换
- 幸运的袋子
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->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;
}
