【C/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  
#include 
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
#include
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
#include
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;
}