笔试强训错题总结（二）

已于 2023-06-12 22:38:21 修改
阅读量959 收藏 12
点赞数 17
分类专栏： 杂项 文章标签： 算法 服务器 c++ 笔试题
于 2023-06-12 22:34:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62633482/article/details/131178253
版权

笔试强训错题总结（二）

选择题

  1. 下列哪一个是析构函数的特征（）

A. 析构函数定义只能在类体内

B. 一个类中只能定义一个析构函数

C. 析构函数名与类名不同

D. 析构函数可以有一个或多个参数

析构函数可以在类中声明，类外定义，一个类只能有一个析构函数，函数名为~类名，不能有参数

所以这题选：B

  1. 若MyClass是一个类名，其有如下语句序列：
MyClass c1，*c2；
MyClass *c3=new MyClass；
MyClass &c4=c1；

上面的语句序列调用构造函数个数是( )

A. 1 B. 2 C. 3 D. 4

只有在创建对象的时候才会调用构造函数，上述代码中c1和c3创建了对象，所以只会调用两次构造函数。

本题选：B

  1. 如果有一个类是 myClass , 关于下面代码正确描述的是:
myClass::~myClass()
{
    delete this;
    this = NULL;
}

A.正确，我们避免了内存泄漏

B. 它会导致栈溢出

C. 无法编译通过

D. 这是不正确的，它没有释放任何成员变量。

这段代码有好几个错误：

1.析构函数是用于对象销毁时，清理对象的资源的，但是并不是所有的类都申请了资源

2.this是const类型，不可更改，所以this=NULL这条语句无法通过编译

3.delete this一定会让程序崩溃

综上所述，这题选：C

  1. C++中关于堆和栈的说法，哪个是错误的（）

A. 堆的大小仅受操作系统的限制，栈的大小一般较小

B. 在堆上频繁的调用new/delete容易产生内存碎片，栈没有这个问题

C. 堆和栈都可以静态分配

D. 堆和栈都可以动态分配

堆的大小只受操作系统的限制（主要取决于操作系统在进程分配时对内存块如何布局），堆的一般比较大（大小在GB级别），栈一般都比较小（大小在MB级别），如果频繁的调用malloc/new在堆上频繁申请小的内存块就会有内存碎片的产生（可以通过内存池来减少碎片），静态分配是指在编译阶段就可以确定需要开辟多大的空间，堆无法做到这点，堆只能动态分配，栈既可以动态分配又可以静态分配，通过alloca函数就可以在栈上动态申请空间。

所以这题选：C

  1. 当一个类对象的生命周期结束后，关于调用析构函数的描述正确的是（）

A. 如果派生类没有定义析构函数，则只调用基类的析构函数

B. 如果基类没有定义析构函数，则只调用派生类的析构函数

C. 先调用派生类的析构函数，后调用基类的析构函数

D. 先调用基类的析构函数，后调用派生类的析构函数

析构函数作为六大默认成员函数，就算我们不去显示的定义，编译器也会自动生成析构函数。而调用析构函数的规则就是先调用派生类的析构，再调用基类的析构函数。

所以这题选：C

  1. 以下关于纯虚函数的说法，正确的是（）

A. 声明纯虚函数的类不能实例化

B. 声明纯虚函数的类成虚基类

C. 子类必须实现基类的

D. 纯虚函数必须是空函数

有纯虚函数的类被称为抽象类，不能实例化对象，如果子类不对父类的纯虚函数进行重写，那么子类也是抽象类（也就是说子类可以不对父类重写），此外纯虚函数并不是只能为空函数：

在这里插入图片描述

所以这题选：A

  1. 下列描述，正确的一共有多少个（）

1)const char *p，这是一个常量指针，p的值不可修改

2)在64位机上，char *p= “abcdefghijk”; sizeof§大小为12

3)inline会检查函数参数，所以调用开销显著大于宏

4)重载是编译时确定的，虚函数是运行时绑定的

A. 1 B. 2 C. 3 D. 4

首先第一个const修饰的是* p也就是说，指针p的值可以更改，但是*p的值不能更改；

p是一个指针，对于64位操作系统而言指针的大小是八个字节，对于32位系统而言指针的大小是四个字节

inline和宏都是在调用的地方展开的，所以它们的调用开销其实是相当的，但是宏没有类型安全的检查，而inline有检查

只有第四个是正确，

所以本题选：A

  1. 下面说法正确的是()

A. 一个空类默认一定生成构造函数,拷贝构造函数,赋值操作符,引用操作符,析构函数

B. 可以有多个析构函数

C. 析构函数可以为virtual,可以被重载

D. 类的构造函数如果都不是public访问属性,则类的实例无法创建

一个空类也具有六大默认成员函数（构造，析构，拷贝构造，赋值重载，普通对象取地址重载，const对象取地址重载）；一个类只能有一个析构函数，析构函数可以为虚函数，可以被重写，但是不能被重载。如果一个类的构造函数是私有的，那么它只能通过公有成员接口来实例化对象；

所以本题选：A
在这里插入图片描述

  1. 以下程序的输出是()
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

func1函数不是虚函数，所以调用只看类型，因此调用的是父类的func1函数，执行i*=10，接下来调用func2函数，因为func2函数是虚函数且被重写，是多态调用（按对象调用），所以调用Child类的func2函数，执行i+=2；所以i=1*10+2=12，

本题选：C

  1. 下面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

首先要明确fun是一个全局函数，它的参数是一个父类对象，而多态的前提是必须要是父类的指针或者引用，所以这里并不构成多态，按类型调用函数，因为是父类的对象，所以都调用的是父类的display函数；

所以本题选：A

  1. 下列哪种函数可以定义为虚函数（）

A. 构造函数 B. 析构函数 C. 内联成员函数 D. 静态成员函数

构造函数是肯定不可以被定义为虚函数的，因为对象都还没完成实例化，而析构函数建议被定义成析构函数，详情可以看：三大特性之多态，内联函数无法被定义为虚函数，因为内联函数是在调用的地方直接展开的，没有地址，也就无法填充虚函数表；虚函数的调用是通过this指针的，静态成员函数没有this指针；

所以本题选：B

  1. 下面关于虚函数的描述，错误的是

A. 在成员函数声明的前面加上virtual修饰，就可把该函数声明为虚函数

B. 基类中说明了虚函数后，派生类中对应的函数也必须说明为虚函数

C. 虚函数可以是另一个类的友元函数，但不能是静态成员函数

D. 基类中说明的纯虚函数在其任何需要实例化的派生类中都必须实现

基类中将该函数声明成虚函数以后，即使派生类不将该函数声明成虚函数，编译器也会将其认为是虚函数；而且重写不是强制要求的，派生类可以不重写基类的虚函数；

所以本题选：B

  1. 下面这段代码的执行结果：
class A
{
public:
	A()
	{
		printf("A ");
	}
	~A()
	{
		printf("deA ");
	}
};
class B
{
public:
	B()
	{
		printf("B ");
	}
	~B()
	{
		printf("deB ");
	}
};
class C : public A, public B
{
public:
	C()
	{
		printf("C ");
	}
	~C()
	{
		printf("deC ");
	}
};
int main()
{
	A* a = new C();
	delete a;
	return 0;
}

A. A B C deA

B. C A B deA

C. A B C deC

D. C A B deC

我要构造一个C对象，而C对象是继承自A类和B类（这里要注意先后顺序，写在前面的类先构造），所以构造顺序是A，B，C，最后delete的时候会调用析构函数，而析构函数不是虚函数，所以直接按类型调用也就是说调用的是A类的析构
所以本题选：A

  1. 在32位环境下，以下程序的输出结构：
#include<iostream>
using namespace std;
class Base
{
public:
	virtual int foo(int x)
	{
		return x * 10;
	}
	int foo(char x[14])
	{
		return sizeof(x) + 10;
	}
};
class Derived : public Base
{
	int foo(int x)
	{
		return x * 20;
	}
	virtual int foo(char x[10])
	{
	
			return sizeof(x) + 20;
	}
};
int main()
{
	Derived stDerived;
	Base* pstBase = &stDerived;
	char x[10];
	printf("%d\n", pstBase->foo(100) + pstBase->foo(x));
	return 0;
}

A. 2000 B. 2004 C. 2014 D. 2024

这段代码糅合了重写和重载，对于整形的foo函数来说，子类重写了父类，构成多态，所以第一个foo函数调用的是子类的，执行x*20，而针对字符数组的foo并没有构成重写，所以按类型调用执行sizeof(x)+10，这里又有一点要注意：字符数组传参的时候其实是传的地址，也就是说char x[14]其实等价于char*x，这是32位系统，指针大小是4个字节，所以最后的结果是：2000+14

所以本题选：C

  1. 假设A为抽象类，下列声明（）是正确的

A. int fun(A); B. A Obj; C. A fun(int); D. A *p;

抽象类是不能实例化对象的，所以凡是出现和对象有关的，都是错误的；只有D选项，虽然是一个A类的指针，但是并没有创建对象

所以本题选：D

  1. 下面代码的输出结果：
#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

vector的删除有迭代器失效的问题，所以在删除的时候都是覆盖删除后再返回当前位置的迭代器，而循环条件中还对迭代器进行了++操作，这就导致了会跳过一些数

在这里插入图片描述

所以本题选：C

  1. 以下代码的运行结果为()
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

因为Derived类继承了Base类，所以在调用构造函数时会首先调用Base类的构造函数，此后在调用Derived的构造函数，随后因为echo构成多态，按对象调用，所以调用的也是Dervied的echo函数

所以本题选：D

编程题

1.跳石板

小易来到了一条石板路前，每块石板上从1挨着编号为：1、2、3…
这条石板路要根据特殊的规则才能前进：对于小易当前所在的编号为K的 石板，小易单次只能往前跳K的一个约数(不含1和K)步，即跳到K+X(X为K的一个非1和本身的约数)的位置。 小易当前处在编号为N的石板，他想跳到编号恰好为M的石板去，小易想知道最少需要跳跃几次可以到达。
例如：
N = 4，M = 24：
4->6->8->12->18->24
于是小易最少需要跳跃5次，就可以从4号石板跳到24号石板

解法

该题要采用动态规划的思想，可以设定两个数组，一个数组存放k的约数来表明在当前位置有几种走法，另一个数组存放从起始位置走到当前位置所需要的最小步数，因为要是最小步数，所以存放步数的数组每次有新的值来临就要和当前值进行比较，如果小于当前值才更新。如果无法抵达就返回-1，判断是否无法抵达可以在初始化的时候做文章，比如将所有位置都初始化为整数的最大值，然后再将起始位置初始化为0，从起始位置往后走，能抵达的每一个位置都会被初始化，最后如果目标位置是整数的最大值就表示无法抵达。

#include<iostream>
#include<vector>
#include<cmath>
#include<limits.h>
using namespace std;

void jump_way(int way,vector<int>&a)
{
    //求约数，1和本身不算
    for(int i=2;i<=sqrt(way);i++)
    {
        if(way%i==0)
        {
             a.push_back(i);
             if(way/i!=i)
                a.push_back(way/i);
            //因为这里开平方了，所以i只能取到约数的一遍，但是只要i是way的约数，那么way/i肯定也是way的约数
        }
    }
}

int Jump(int n,int m)
{
    //主要过程在这个函数中进行
    vector<int>step(m+1,INT_MAX);//数组用于存放起始位置到当前位置的最小步数
    step[n]=0;

    for(int i=n;i<=m;i++)
    {
        if(step[i]==INT_MAX)//第一次是起始位置，所以可以往后执行，并且会将所有可达位置改变为其他值，最后要是某个位置还是INT_MAX,说明该点不可达
            continue;

        vector<int> a;//这个数组用来存放约数个数
        jump_way(i,a);
        //a数组中存放的是i位置的约数
        for(int j=0;j<a.size();j++)
        {
            //如果位置合法，需要挑选一个最小值
            if(a[j]+i<=m&&step[a[j]+i]!=INT_MAX)
            {
                step[a[j]+i]=min(step[a[j]+i],step[i]+1);//这个位置已经被初始化过了，那么就要比较一下此次步数和之前的步数哪个小
            }
            else if(a[j]+i<=m)
            {
                step[a[j]+i]=step[i]+1;
            }
        }
    }

    return step[m]==INT_MAX ? -1:step[m];

}

int main()
{
    int n,m,minstep;

    while(cin>>n>>m)//n表示当前位置，m是目标位置
    {
        //通过jump函数来得到最小步数
        minstep = Jump(n,m);
        cout<<minstep<<endl;
    }
    return 0;
}

2.扑克牌大小

扑克牌游戏大家应该都比较熟悉了，一副牌由54张组成，含3~A，2各4张，小王1张，大王1张。牌面从小到大用如下字符和字符串表（其中，小写joker表示小王，大写JOKER表示大王）😃
3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER
输入两手牌，两手牌之间用“-”连接，每手牌的每张牌以空格分隔，“-”两边没有空格，如：4 4 4 4-joker JOKER 请比较两手牌大小，输出较大的牌，如果不存在比较关系则输出ERROR

基本规则：
（1）输入每手牌可能是个子，对子，顺子（连续5张），三个，炸弹（四个）和对王中的一种，不存在其他情况，由输入保证两手牌都是合法的，顺子已经从小到大排列；
（2）除了炸弹和对王可以和所有牌比较之外，其他类型的牌只能跟相同类型的存在比较关系（如，对子跟对子比较，三个跟三个比较），不考虑拆牌情况（如：将对子拆分成个子）
（3）大小规则跟大家平时了解的常见规则相同，个子，对子，三个比较牌面大小；顺子比较最小牌大小；炸弹大于前面所有的牌，炸弹之间比较牌面大小；对王是最大的牌；
（4）输入的两手牌不会出现相等的情况。

答案提示：
（1）除了炸弹和对王之外，其他必须同类型比较。

（2）输入已经保证合法性，不用检查输入是否是合法的牌

（3）输入的顺子已经经过从小到大排序，因此不用再排序了.

输入描述:

输入两手牌，两手牌之间用“-”连接，每手牌的每张牌以空格分隔，“-”两边没有空格，如4 4 4 4-joker JOKER。

输出描述:

输出两手牌中较大的那手，不含连接符，扑克牌顺序不变，仍以空格隔开；如果不存在比较关系则输出ERROR。

解题思路

这个题目描述真是长到吓人，但其实真正重要的是以下几点：

1.两手牌输入到同一个字符串中，以-分割，这就暗示了我们要在程序中以-位分割符来得到两手牌

2.只有炸弹和王炸可以跟其他类型的牌比较，其他的都只能跟同类型的牌比较，并且只需要比第一张牌的大小即可（因为是有序的）

3.已经保证了输入的合法性，也就是说如果长度相同肯定是同类型的，长度不同且不是王炸，那肯定是“ERROR”

所以首先要切割字符串得到两手牌，再看两个子串的长度是否相等，如果相等就比较点数，如果不相等就看是否有炸弹，如果既不相等，又没有炸弹，那么就输出"ERROR"，此外王炸是最大的牌，可以在程序的开始判断是否有王炸，如果有，就直接输出王炸。此外还有两点需要注意：1.扑克牌大小的比较规则和数字有些不同，所以可以再设置一个字符串，在这个字符串中位置越靠后，点数越大；2.关于牌的张数不能使用size函数，这里可以使用算法库中的count函数

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

string bigstr(const string&car)
{
    if(car.find("joker JOKER")!=string::npos)
        return "joker JOKER";//王炸最大

    //首先要切割字符串得到两手牌
    string car1,car2;
    int pos=car.find('-',0);
    car1=car.substr(0,pos);
    car2=car.substr(pos+1);

    //判断两手牌的长度是否一致
    int cnt1=count(car1.begin(),car1.end(),' ')+1;//count查找的是空格的个数，空格的个数+1就是字符个数
    int cnt2=count(car2.begin(),car2.end(),' ')+1;
    if(cnt1==cnt2)
    {
        //两手牌个数相等，比较第一张牌的大小，但是这里有一个问题，就是说比较规则并不是单纯按大小，所以这里又可以设置一个字符串，位置越靠后点数越大
        string car1_first=car1.substr(0,car.find(' '));
        string car2_first=car2.substr(0,car2.find(' '));
        string comp="345678910JQKA2jokerJOKER";

        if(comp.find(car1_first)>comp.find(car2_first))
            return car1;
        return car2;
    }

    //类型不一致看是不是炸弹
    if(cnt1==4)
        return car1;
    if(cnt2==4)
        return car2;
    return "ERROR";
}

int main()
{
    string str,res;
    
    while(getline(cin,str))
    {
        res=bigstr(str);
        cout<<res<<endl;
    }
    return 0;
}

3.杨辉三角的变形

在这里插入图片描述

以上三角形的数阵，第一行只有一个数1，以下每行的每个数，是恰好是它上面的数、左上角数和右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。

求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3，输入2则输出-1。

解题思路

这题有两种解法：

1.可以构建一个二维数组，然后根据输入的n生成一个n行的杨辉三角，每行的列数就是行数的两倍（从0开始），构造完杨辉三角以后直接根据输入的行数进到里面查找，但是这样会显示超出内存限制

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

int findnum(int n)
{
    //创建二维数组，生成杨辉三角
    vector<vector<int>> vv(n,vector<int>(2*n-1,0));

    //初始化
    vv[0][0]=1;

    for(int i=1;i<n;i++)
    {
        vv[i][0]=vv[i][2*i]=1;//第一列和最后一列都是1

        //除了第二列和倒数第二列都是两个数相加以外，其他位置的数都是三个数相加  
        for(int j=1;j<2*i;j++)
        {
            if(j==1)
                vv[i][j]=vv[i-1][j]+vv[i-1][j-1];
            else if(j==2*i-1)
                vv[i][j]==vv[i-1][j-2]+vv[i-1][j-1];
            else 
                vv[i][j]=vv[i-1][j]+vv[i-1][j-1]+vv[i-1][j-2];
            
             
        }
        
    }

    //初始化完毕，随后开始查找
    for(int j=0;j<2*n-1;j++)
    {
        if(vv[n-1][j]%2==0)
            return j+1;
    }
    return -1;
}

int main()
{
    int n;
    cin>>n;

    int ret=findnum(n);
    cout<<ret<<endl;
}

解法二

2.这里有个规律：仔细观察可以发现，第一行和第二行是没有偶数的；如果行数是奇数，那么它的第二列就是就是偶数，如果行数是4的倍数，那么偶数就在第三个位置，除此之外偶数都在第四个位置；（这里的行数是从1开始的）

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

int findnum(int n)
{
    if(n<=2)
        return -1;
    if(n%2==1)
        return 2;
    if(n%4==0)
        return 3;
     
    return 4;
}

int main()
{
    int n;
    cin>>n;

    int ret=findnum(n);
    cout<<ret<<endl;
}

4.字符串通配符

问题描述：在计算机中，通配符一种特殊语法，广泛应用于文件搜索、数据库、正则表达式等领域。现要求各位实现字符串通配符的算法。
要求：
实现如下2个通配符：

*：匹配0个或以上的字符（注：能被 *和?匹配的字符仅由英文字母和数字0到9组成，下同）
？：匹配1个字符

注意：匹配时不区分大小写。

输入：
通配符表达式；
一组字符串。

输出：

返回不区分大小写的匹配结果，匹配成功输出true，匹配失败输出false

输入描述：

先输入一个带有通配符的字符串，再输入一个需要匹配的字符串

输出描述：

返回不区分大小写的匹配结果，匹配成功输出true，匹配失败输出false

解题思路

起初我想以暴力匹配的方式尝试解决这道题，但是无论如何也无法通过题解，最后发现题目说*可以匹配一个或者以上的字符，这句话的意思或许是在说，有时候*不用匹配字符，有时候却需要匹配一个或者多个字符；

于是这题可以选用递归的思想来解决，大致分为三种情况：

1.两者走到末尾，肯定是匹配的

2.两者只有一者走到末尾，这种情况就是不匹配

3.以上两种情况都是递归的结束条件，如果不是以上两种情况，如果当前是*那么可以递归匹配0个，匹配1个或者匹配多个；如果是?那么就只匹配一个；这里面还有一些注意事项，就是因为*可以匹配一个或者多个字符，所以一个*和多个*其实是一样的，如果有多个*我们要把它归成一个*来处理，否则会出现时间复杂度过大，此外因为不区分大小写，所以可以使用tolower函数来帮助匹配

#include <iostream>
#include<string>
using namespace std;

bool ismatch(const char*match,const char*str)
{
    if(*match=='\0'&&*str=='\0')
        return true;
    if(*match=='\0'||*str=='\0')
        return false;

    if(*match=='?')
    {
        if(!isdigit(*str)&&!isalpha(*str)) 
            return false;
        return ismatch(match+1,str+1);
    }
        
    else if(*match=='*')
    {
        while(*match=='*')
        {
            match++;
        }
        match--;//前面的循环中将*全部跳过了，但是我们的本意是当成一个*来处理，所以这里要回退一位
        
    if(!isdigit(*str)&&!isalpha(*str))
             return false;
         return ismatch(match+1,str)||ismatch(match+1,str+1)||ismatch(match,str+1);
    }
       
    else if(tolower(*match)==tolower(*str))
        return ismatch(match+1,str+1);

    return false;
}

int main()
{
    string match,str;
    while(cin>>match>>str)
    {
       
        bool ret=ismatch(match.c_str(),str.c_str());
        if(ret)
            cout<<"true"<<endl;
        else
            cout<<"false"<<endl;
    }
     return 0;

}
别动我的饭
关注
  • 17
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 25
    评论
专栏目录
c++笔记总结5.26
m0_66484415的博客
06-03 263
9.4 纯虚函数和抽象类 纯虚函数是一种特殊的虚函数，在基类中声明纯虚函数，不给出其具体实现，在派生类中给出具体实现，基类中的纯虚函数只是一个入口。 virtual 函数类型 函数名（参数表）=0； 包含纯虚函数的基类称为抽象类 说明： （1）可以定义抽象类的指针/引用，从而实现动态多态 （2）但抽象类不能建立对象、不能作为函数返回类型、不能作为函数参数的类型、不能用于强制类型转换，只能作为其他类的基类来使用（因为纯虚函数没有具体的实现）例： （3）区分：空函数 函数体为空 把函数名赋予0，
2009年二级笔试样卷c++语言程序设计 答案,全国计算机等级考试二级笔试样卷C++语言程序设计...
weixin_39843738的博客
05-17 118
一、选择题((1)～(35)每小题2分，共70分)下列各题A)、B)、C)、D)四个选项中，只有一个选项是正确的，请将正确选项涂写在答题卡相应位置上，答在试卷上不得分。(1)下列选项中不符合良好程序设计风格的是A)源程序要文档化 B)数据说明的次序要规范化C)避免滥用goto语句 D)模块设计要保证高耦合、高内聚(2)从工程管理角度，软件设计一般分为两步完成，它们是A)概要设计与...
C++期末、笔试易错题整理含答案，解析（三）
weixin_43672168的博客
03-23 879
C++期末、笔试易错题整理含答案，解析（三）
display 各值的区别
m0_59070120的博客
07-27 160
inline-block行内元素，可以设置宽高，一行显示，可以设置水平方向的padding和margin，不可以设置垂直方向的padding和margin；inline内联元素，不可以设置宽高、可以设置水平方向的padding和margin，不可以设置垂直方向的padding和margin；block块级元素，可以设置宽高，也可以设置padding和margin；自动换行，多个块状元素，默认从上到下显示。隐藏元素，不会被子元素继承，不占据位置，直接从render树上移除。...
笔试强训选择题错误总结
08-25
笔试强训选择题错误总结
笔试强训day2选择题
05-10
"Java笔试强训Day2选择题知识点总结" 本节笔试强训Day2选择题主要涵盖了Java语言的基础知识点，包括继承、方法调用、变量声明、静态方法、抽象类和构造方法等。下面是对每个知识点的详细解释： 1. Java继承机制 ...
c语言笔试题总结.doc
11-24
C语言笔试题总结 本资源摘要信息总结了C语言笔试题的主要知识点，涵盖了数据结构、算法、软件开发过程、数据存储、关系代数运算等方面的内容。 一、数据结构 * 逻辑结构：反映数据元素之间的逻辑关系，包括线性...
FPGA笔试题及答案总结.pdf
04-21
FPGA 笔试题及答案总结 本笔试题总结主要涵盖了 FPGA 基础知识、FPGA 设计流程、开发工具、文件管理、IC 设计流程、设计规则、测试、FPGA 基本结构等方面的知识点。 FPGA 基础知识 FPGA 设计工程师需要努力的方向...
C语言笔试基础总结.txt
03-17
C语言笔试基础总结.txtC语言笔试基础总结.txtC语言笔试基础总结.txtC语言笔试基础总结.txtC语言笔试基础总结.txtC语言笔试基础总结.txtC语言笔试基础总结.txtC语言笔试基础总结.txtC语言笔试基础总结.txtC语言笔试...
牛客 题库 若MyClass是一个类名，其有如下语句序列：
Zender
09-10 4752
1.若MyClass是一个类名，其有如下语句序列： MyClass c1，*c2； MyClass *c3=new MyClass； MyClass &c4=c1； 上面的语句序列调用构造函数个数是( )。 1 2 3 4 解答：B 只要类的对象被创建，就会执行构造函数。 第1行：创建对象c1，调用了构造函数； 第2行：声明了一个
牛客C++专项训练6.8
Sarah_212的博客
06-08 682
1.如果定义了一个类myclass,则为myclass类对象以成员函数形式重载后++运算符的声明应该是： 正确答案: B 你的答案: C A myclass operator++() B myclass operator++(int) C myclass &operator++() D myclass &operator（int) 重载单目运算符++或（--）作为前缀和后缀是不同的 #include <iostream> using ...
纯虚析构函数必须有定义(可以是空的)
qq_34581491的博客
01-16 1459
纯虚析构函数必须有定义(可以是空的)，一般就给一个空的 #include class A { public: explicit A(int x) : m_nX(x) {} virtual ~A() = 0;// 纯虚析构函数必须有定义并且会执行 virtual void f1() = 0 /*{ std::cout << "A::f1()" << std::endl; }*/;// 纯
c++中虚函数和纯虚函数定义
richerg85的专栏
07-01 7410
只有用virtual声明类的成员函数，使之成为虚函数，不能将类外的普通函数声明为虚函数。因为虚函数的作用是允许在派生类中对基类的虚函数重新定义。所以虚函数只能用于类的继承层次结构中。      一个成员函数被声明为虚函数后，在同一类族中的类就不能再定义一个非virtual的但与该虚函数具有相同的参数（包括个数和类型）和函数返回值类型的同名函数。        根据什么考虑是否把一个成员
虚函数必须定义（纯虚函数除外）
qq_20949431的博客
04-25 6975
1. 虚函数的声明和定义 具体关于虚函数的知识不做多讲，我在定义一个抽象类时，忘了将一个虚函数声明为 纯虚函数，又没有对其定义， 导致编译报错时报错如下： undefined reference to `vtable for Fibonacci' 错误提示的很明显，就是无法生成虚函数表。 我们知道，虚函数表(地址)在定义了虚函数的类所实例化的对象内存中的第一个位置，也就是在实例化过
C++ 的纯虚函数一定要在子类实现呀
热门推荐
catalpeak的博客
04-06 1万+
C++的纯虚函数作为多态很重要的一环，充当了给子类接口的功能。但是这个接口一定要在子类实现才能通过编译。 但是为什么一定要在子类实现呢？？？？ 首先我们要明确一个概念，就是函数申请时我们在函数体里什么都没有写 void func () {} 这样的函数我们称其为空函数，但是函数体里也是有内容的，内容是空，相当于集合里的空集。所以只要有内容存在就没有问题的可以为函数申请内存。 但是我们再...
C++纯虚函数定义
qq_27898413的博客
07-11 755
有时候，基类中的虚函数是为了派生类中的使用而声明定义的。此类函数我们叫做纯虚函数，不需要写成空函数的形式，一般只需要声明成： virtual 函数类型 函数名（形参表列）=0; 最后面的“=0“并不代表函数返回值为0，只是形式上的作用，告诉编译系统”这是纯虚函数”； 这是一个声明语句，最后应有分号。 但是，不代表此函数不能定义，下面转载的文章说明了对纯虚函数定义和调用的方式 看代码时时无意看到代码里某类的纯虚函数居然有实现，吓我一跳，果真学无止境啊！ 在此转载相关文...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 931
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
最新发布
bless_______的博客
07-24 229
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

别动我的饭

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

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

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

打赏作者

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

抵扣说明：

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

余额充值