文章详细解析了C++中抽象类的特性、虚函数与内联函数的区别、多态的实现机制、迭代器失效示例、动态联编、引用与多态的关系，以及如何通过编程解决杨辉三角变形和字符出现次数计算问题。
文章目录
C/C++笔试练习
选择部分
（1）抽象类不能实例化
假设A为抽象类，下列声明（）是正确的
A. int fun(A);
B. A Obj;
C. A fun(int);
D. A *p;
答案：D
A. int fun(A); - 这是一个函数声明，它表示有一个函数fun接受一个类型为A的参数并返回一个int。但是需要给fun传递一个抽象类对象A，抽象类是一种特殊的类，它不能被实例化。
B. A Obj; - 这是错误的。抽象类不能被直接实例化，所以不能创建抽象类的对象。
C. A fun(int); - 这是一个函数声明，表示有一个函数fun接受一个int参数并返回一个类型为A的对象。这是错误的，因为不能返回抽象类的对象。
D. A *p; - 我们可以声明一个指向抽象类的指针。 虽然不能实例化抽象类，但你可以有指向它的指针或引用，这些指针或引用可以指向抽象类的非抽象派生类的对象。所以，答案选D。
（2）虚函数不能定义为内联
虚函数可不可以重载为内联？
A. 可以
B. 不可以
C. 语法错误
答案：B
虚函数不可以被重载成为内联函数。因为内联函数会展开，但是虚函数是函数地址存放在虚表中，如果内联函数根据地址展开，就无法找到函数地址。 这是因为内联函数要求在编译时确定其调用形式，而虚函数的调用形式在编译时是不确定的，只能在运行时动态地确定。
（3）虚函数和多态
下面有关虚函数的描述，说法错误的是？
A. 虚函数的作用是实现了继承性
B. 虚函数的作用就是实现“动态联编”，也就是在程序的运行阶段动态地选择合适的成员函数
C. 和类的静态成员函数与非类的成员函数相比，虚函数的效率较低
D. 要正确的实现虚函数，只能用一个基类的指针或者引用来指向派生类对象
答案：A
虚函数的主要作用是实现动态多态性，即在运行时根据对象的实际类型选择合适的成员函数。这与继承性（即派生类可以继承基类的成员）是不同的概念。
（4）迭代器失效
#include <iostream>
#include <vector>
using namespace std;
int main(void)
{
vector<int>array;
array.push_back(100);
array.push_back(300);
array.push_back(300);
array.push_back(300);
array.push_back(300);
array.push_back(500);
vector<int>::iterator itor;
for(itor=array.begin();itor!=array.end();itor++)
{
if(*itor==300)
{
itor=array.erase(itor);
}
}
for(itor=array.begin();itor!=array.end();itor++)
{
cout<<*itor<<"";
}
return 0;
}
下面这个代码输出的是（）
A. 100 300 300 300 300 500
B. 100 300 300 300 500
C. 100 300 300 500
D. 100 300
答案：C
vector<int>::iterator itor;
for (itor = array.begin(); itor != array.end(); itor++)//2.迭代器++,此时跳过自身指向300的位置，指向下一个300
{
if (*itor == 300)
{
itor = array.erase(itor);//1.此时将后面的4个数据前移一位以此达到删除目的 3.再重复一次
}
}
for (itor = array.begin(); itor != array.end(); itor++) //100 300 300 300 300 500
{ //100 300 300 300 500
cout << *itor << " "; //100 300 300 500
}
（5）多态的实现
在 C++ 中，用于实现动态多态性的是（ ）
A. 内联函数
B. 重载函数
C. 模板函数
D. 虚函数
答案：D
在C++中，用于实现动态多态性的是虚函数（virtual function）。虚函数允许派生类覆盖基类中的函数，从而在运行时根据对象的实际类型选择合适的成员函数。
（6）动态联编
调用一成员函数时, 使用动态联编的情况是（）
A. 通过对象调用一虚函数
B. 通过指针或引用调用一虚函数
C. 通过对象调用静态函数
D. 通过指针或应用调用一静态函数
答案：B
动态联编是指在运行时根据对象的实际类型选择合适的成员函数。通过指针或引用调用虚函数时，会根据指针或引用所指向对象的实际类型来确定要调用的函数，这就是动态联编。因此，选项B是正确的。
（7）覆盖的定义
下面有关继承、多态、组合的描述，说法错误的是?
A. 封装，把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏
B. 继承可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展
C. 隐藏是指派生类中的函数把基类中相同名字的函数屏蔽掉了
D. 覆盖是指不同的函数使用相同的函数名，但是函数的参数个数或类型不同
答案：D
覆盖是指派生类中的函数（虚函数）与基类中的函数（虚函数）具有相同的函数名和参数列表，从而在运行时根据对象的实际类型选择合适的成员函数。而重载是指在同一个作用域内，多个函数具有相同的函数名，但是函数的参数个数或类型不同。
重载（Overload）、重写（Override）和重定义（Hide）是面向对象编程中的三个概念，用于描述派生类对基类成员的处理方式。
（1）重载（Overload）： 重载是指在同一个作用域内，根据函数名相同但参数列表不同的规则，定义多个具有相同名称但参数不同的函数。 重载函数可以有不同的返回类型，但不能仅通过返回类型的不同来进行重载。在调用重载函数时，编译器会根据函数调用的参数类型和数量来确定调用哪个重载函数。
（2）重写（Override）： 重写是指在派生类中重新定义基类的虚函数。派生类中的重写函数具有相同的函数名、参数列表和返回类型，它们用于替代基类中的虚函数。 在运行时，通过基类指针或引用调用虚函数时，会根据实际对象的类型调用相应的派生类的重写函数。重写函数可以通过使用override关键字来显式地标记。
（3）重定义（Hide）： 重定义是指在派生类中定义一个与基类中的非虚函数同名的函数。 在派生类中的重定义函数与基类中的函数没有关联，它们是完全独立的函数。在运行时，通过基类指针或引用调用函数时，会根据指针或引用的类型调用相应的函数。重定义函数不需要使用特定的关键字进行标记。
（8）引用和多态
“引用”与多态的关系？
A. 两者没有关系
B. 引用可以作为产生多态效果的手段
C. 一个基类的引用不可以指向它的派生类实例
D. 以上都不正确
答案：B
引用与多态之间存在密切关系。在C++中，通过基类的引用或指针来调用虚函数时，会根据对象的实际类型来确定要调用的函数，这就是动态多态性。因此，引用可以作为产生多态效果的手段。
选项A错误，因为引用与多态是相关的。选项C错误，因为一个基类的引用可以指向它的派生类实例，只要派生类是public继承基类的。选项D错误，因为B是正确的答案。
（9）程序分析
下面这段程序的输出是什么
class A{
public:
A() {p();}
virtual void p() {printf("A");}
virtual ~A() {p();}
};
class B:public A{
public:
B() {p();}
void p() {printf("B");}
~B() {p();}
};
int main(int, char**)
{
A* a=new B();
delete a;
}
A. AABB
B. BBAA
C. ABAB
D. ABBA
答案：D
class A {
public:
A() { p(); }//1.构造函数时期还没有产生虚表，不会调用子类对象，先调用父类的p()，打印A
virtual void p() { printf("A"); }
virtual ~A() { p(); }//4.再调用父类析构p()，打印A
};
class B :public A {
public:
B() { p(); }//2.再构造子类的对象，调用子类的p()，打印B
void p() { printf("B"); }
~B() { p(); }//3.虚表生成了，因为有虚机制，先调用子类析构p()，打印B
};
int main(int, char**)
{
A* a = new B();//创建B子类对象，用父类指针a指向
delete a;
}
（10）程序分析
以下代码的运行结果为（）
class Base {
public:
Base() {echo();}
virtual void echo() {printf("Base");}
};
class Derived:public Base {
public:
Derived() {echo();}
virtual void echo() {printf("Derived");}
};
int main()
{
Base* base = new Derived();
base->echo();
return 0;
}
A. DerivedDerivedDerived
B. DerivedBaseDerived
C. BaseDerivedBase
D. BaseDerivedDerived
答案：D
class Base {
public:
Base() { echo(); }//1.1先调用父类构造函数echo()，打印Base
virtual void echo() { printf("Base"); }
};
class Derived :public Base {
public:
Derived() { echo(); }//1.2再调用子类构造函数echo()，打印Derived
virtual void echo() { printf("Derived"); }//2.1多态形成，父类指针调用子类函数echo()，打印Derived
};
int main()
{
Base* base = new Derived();//1.先生成子类对象，用父类指针指向，此时多态形成
base->echo();//2.因为多态，父类指针调用子类函数echo()
return 0;
}
编程题 day17
杨辉三角的变形
解题思路：按照题目意思，可以发现第n行有2n - 1个元素，第i,j元素等于上一行第j - 2,j - 1,j三列元素之和，每一行的第一列和最后一列都为1，如果是第二列，则只是两个元素之和。通过以上的数据分析规律为 {-1,-1,2,3,2,4,2,3,2,4,…} ，即第n行上偶数所在的下标。
#include<iostream>
#include<string>
using namespace std;
int main(int argc, char* argv[])
{
int nRow = 0;
while (cin >> nRow)
{
int res = -1;
int myInt[] = {4, 2, 3, 2};
if (nRow > 2)
res = myInt[(nRow - 2) % 4];
cout << res << endl;
}
return 0;
}
计算某字符出现次数
解题思路：因为在计算字符出现次数中，要求是不区分大小写的，因此在处理过程中，如果输入的是小写字母，则计数不但要加上小写字母的计数，还要加上大写字母的计数，反之大写字母也是同样如此，而在 ascii 表中，大写字母和小写字母的差值是 32 （ 'a’的ascii值是97 ; 'A’的ascii值是65 ）。
因为 ascii字符 只有 128 个，他们的实际存储是 0~127 ，那么我们只需要定义一个具有128 个整形元素的数组，第 0 号下标位置存放 0 对应的 ascii字符 出现次数， 1 号下标位置存放 1 对应的 ascii字符 的次数…以此类推，数组每个位置存放的就是对应 ascii字符 出现的次数。最终以指定字符为下标获取它出现的次数进行打印。
#include<iostream>
#include<string>
using namespace std;
int main()
{
string str;
char c;
while(getline(cin,str)&&cin>>c)
{
int hash[128]={0};
for(int i=0;i<str.size();i++)
{
if(str[i]>='A'&&str[i]<='Z')
{
hash[str[i]+32]++;
}
else hash[str[i]]++;
}
if(c>='A'&&c<='Z')
{
cout<<hash[c+32]<<endl;
}
else cout<<hash[c]<<endl;
}
return 0;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
