1. 虚函数是可以[New一个对象的时候要根据虚函数的函数体来填虚表；而内联函数没有函数体，只是在预编译阶段展开]内联的，这样就可以减少函数调用的开销，提高效率（错误）
2. 一个类里可以同时存在[同一个类里无论什么函数都不能函数名和参数完全一样]参数和函数名都相同的虚函数与静态函数（错误）
3. 父类的析构函数是非虚的，但是子类的析构函数是虚的，delete子类指针(指向该子类对象)[特殊情况，参见题5]，会调用父类的析构函数（正确）//任何情况下删除子类都会调用到父类的析构函数
4．对于下面的类CA，sizeof(CA) = _B_：
A. 4 B. 8 C. 12 D. 16
class CA
{
public:
CA();
virtual ~CA(); //因为有虚函数，所以会有4个字节的虚表指针
private:
int m_iTime; //成员变量4个字节
public:
int GetTime();
int SetTime(int iTime);
};
5．下面这段程序，打印结果是_A_：
A. 1 B. 2 C. 3 D. 以上都不对
int g_iCount = 0;
class CParent
{
public:
CParent() {}
~CParent() {g_iCount += 1;}
};
class CSon : public CParent
{
public:
CSon() {}
~CSon() {g_iCount += 2;}
};
main()
{
CParent* p = new CSon();
delete p[由于p被声明成父类指针，并且父类和子类的析构函数都非虚，因此delete操作只能根据p指针声明的类型来调用父类的析构函数];
std::cout << g_iCount << std::endl;
}
6．请问下面这段程序的输出结果是_A_：
A. 2,1, B. 2,2, C. 1,1, D. 1,2,
class CParent
{
public:
CParent() {}
virtual ~CParent() {}
public:
virtual void Print()
{ std::cout << "1,"; };
};
class CSon : public CParent
{
public:
CSon() {};
virtual ~CSon() {};
public:
void Print()
{ std::cout << "2,"; };
};
void Test1(CParent& oParent[这里是引用了一个外部对象，该对象的虚表不会发生变化])
{oParent.Print();}
void Test2(CParent oParent[这里会在栈空间内重新构造一个CParent类的对象，如果传入实参的类型与CParent不同则虚表会发生变化])
{oParent.Print();}
main()
{
CSon * p = new CSon();
Test1(*p); //这里只是一个引用
Test2(*p); //这里会在栈空间重新构造Cparent类对象
delete p;
}
7．请问下面这段程序的输出结果是_D_：
A. 2,1, B. 2,2, C. 1,1, D. 1,2,
class CParent
{
public:
CParent() {}
virtual ~CParent() {}
public:
void Print(){ std::cout << "1," ; };
};
class CSon : public CParent
{
public:
CSon() {}
virtual ~CSon() {}
public:
void Print(){ std::cout << "2,"; };
};
main()
{
CSon oSon;
CParent * pParent = &oSon;
CSon * pSon = &oSon;
pParent->Print();
pSon->Print();[由于父类和子类的Print函数都非虚，所以根据指针类型决定调用关系]
}
8．请问下面这段程序的输出结果是_C_：
A. 2,1, B. 2,2, C. 1,2, D. 1,1,
class CParent
{
public:
CParent() {Print();}
virtual ~CParent() {}
public:
virtual void Print(){ std::cout << "1,"; }
};
class CSon : public CParent
{
public:
CSon() {Print();}
virtual ~CSon() {}
public:
void Print(){ std::cout << "2,"; }
};
main()
{
CParent * pParent = new CSon()[类的构造过程遵循压栈原则，构造过程中虚表尚未建立成功，是静态调用虚函数];
delete pParent;
}
9．请问下面这段程序的输出结果是_D_：
A. 2,2, B. 2, C. 输出结果不确定 D. 以上都不对
class CParent
{
public:
CParent() {Print();[构造子类对象时调用到父类的构造函数，但父类的Print函数是纯虚的，没有实现，所以这里的调用不成功，编译会出错]}
virtual ~CParent() {}
public:
virtual void Print() = 0;
};
class CSon : public CParent
{
public:
CSon() {Print();}
virtual ~CSon() {}
public:
void Print()
{ std::cout << "2,"; };
};
main()
{
CParent * pParent = new CSon();
delete pParent;
}
10．请仔细阅读以下程序：
class Base
{
public:
virtual bool operator == (int iValue)
{
std::cout << "I am Base class !" << std::endl;
return true;
}
virtual ~Base(){}
};
class Derive: public Base
{
public:
virtual bool operator == (int iValue)
{
std::cout << "I am Derive class !" << std::endl;
return true;
}
virtual ~Derive(){}
};
int main()
{
Derive derive;
Base* pBase = &derive;
Derive* pDerive = &derive;
*pBase == 0;
*pDerive == 0;[重载操作符声明为virtual使操作符产生多态性]
return 0;
}
程序的输出结果是_B_：
A、I am Base class !
I am base class !
B、I am Derive class !
I am Derive class !
C、I am base class !
I am Derive class !
D、I am Derive class !
I am Base class !
【知识点详解】
1. 虚函数与内联函数：
虚函数的主要目的是实现多态性，它允许通过基类指针或引用来调用派生类的重写函数。内联函数是为了减少函数调用的开销，通过在编译时将函数体展开。然而，虚函数不能被内联，因为内联发生在编译时，而虚函数的解析是在运行时基于虚表。因此，虚函数和内联函数的概念是冲突的，不能同时用于同一函数。
2. 同名虚函数与静态函数：
在C++中，同一个类内的函数名和参数不能完全相同，这是为了避免名字冲突。但这并不意味着不能同时存在虚函数和静态函数，它们可以有不同的参数列表或者返回类型。因此，一个类里可以同时包含同名但参数不同的虚函数和静态函数。
3. 析构函数的虚性：
父类的析构函数默认是非虚的，但子类的析构函数通常是虚的。当用子类指针删除子类对象时，由于子类析构函数的虚性，会调用到子类的析构函数，然后调用父类的析构函数。但如果析构函数不是虚的，只会调用指针类型所对应的类的析构函数，不会涉及子类。
4. sizeof(CA)：
类`CA`含有一个虚函数，因此会有一个4字节的虚表指针，加上一个4字节的`int`成员变量`m_iTime`，所以`sizeof(CA)`应该是8字节，选项B正确。
5. 程序打印结果：
由于`CParent`和`CSon`的析构函数都不是虚的，且`p`被声明为`CParent`指针，所以`delete p`只会调用`CParent`的析构函数，`g_iCount`的值增加1，最后输出为1。
6. 程序输出：
`Test1`传递的是引用，不会创建新对象，所以调用的是`CSon`的`Print`。`Test2`传递的是值，会在栈上创建一个新的`CParent`对象，因此调用`CParent`的`Print`。所以输出为`2,1,`。
7. 程序输出：
`Print`函数在`CParent`和`CSon`中都是非虚的，所以调用哪个版本的`Print`取决于指针的类型。`pParent`是基类指针，调用`CParent`的`Print`，而`pSon`是子类指针，调用`CSon`的`Print`。因此输出为`1,2,`。
8. 程序输出：
在构造`CParent`对象时，由于`Print`是虚函数，所以在调用`Print`时会根据对象的实际类型（`CSon`）进行调用，输出`2,2,`。
9. 程序错误：
父类`CParent`的构造函数尝试调用纯虚函数`Print`，这是不允许的，因为纯虚函数没有定义，编译时会报错，程序无法执行。
10. 重载操作符的多态性：
当`operator==`被声明为虚函数时，它可以表现出多态性。在这个例子中，无论是`Base`指针还是`Derive`指针调用`operator==`，都会调用对应对象的版本。因此，输出为`I am Derive class !I am Derive class !`。
总结：这些题目涵盖了C++中的虚函数、析构函数的虚性、内联函数、对象构造与析构、多态性、引用和值传递的区别、虚表指针、以及重载操作符的多态行为等多个核心概念。在实际编程中，理解并掌握这些知识点对于编写高效、安全的代码至关重要。
- 1
- 2
前往页