我在想,这可能是一个重复的问题,但我试着阅读了几乎所有相关的帖子,没有一个是我正在寻找的具体问题。
好的,我知道你不能从基类指针调用派生类中的函数,除非它被标记为虚拟的。就像在参考程序1中一样,如果WhichClass()没有被标记为虚拟,它就不能调用B类的WhichClass()。
#include<iostream>
using namespace std;
class A
{
public:
const char* WhichClass(){return "A";}
};
class B:public A
{
public:
const cha
我只是试着理解下面这段代码,但在最后无法理解这两行代码。
ptr = &D;
ptr->show();
我实际上是在学习多态性概念的路上。这只是最基本的。因此,请解释一下它是如何工作的,以及为什么ptr->show()在base中调用函数。
#include <iostream>
using namespace std;
class Base {
public:
void show()
{
cout << "This is the base\n";
请查看以下代码清单:
#include <iostream>
using namespace std;
class Base {
public:
virtual void Message() = 0;
};
class Intermediate : public Base {
};
class Final : public Intermediate {
void Message() {
cout << "Hello World!" << endl;
}
};
int main() {
我正在努力学习C++,并编写了这段代码。根据我的理解,这段代码需要以"Derived Class"的形式生成输出,但是输出是"Base Class"。请帮我理解一下。
#include <iostream>
using namespace std;
class Base {
public:
char* name;
void display() {
cout << name << endl;
}
};
class Derived: public Base {
有关:数组C++中的子类
嗨,伙计们,抱歉,我被困在工作上了。
基本上这就是发生的事
我有一个父类呼叫工具,它接到两个子类呼叫。
Car and Motorcycle
父类具有以下值:
string Name: value either Car or MotorCycle
wheels : 4 or 2 (depends is car or motorcycle)
Notes On Wheel:
wheel[0] : Fine condition
wheel[1] : need some repair
wheel[2] : Fine condition
wheel[3] : Fine cond
using namespace std;
class Base
{
public:
void print(){printf("base\n");}
};
class Derived:public Base
{
public:
void print(){printf("derived\n");}
};
int main()
{
Base* bptr= new Base;
Derived* pptr=static_cast<Derived*> (bptr);
p
在下面的示例中: class A
{
public:
A();
virtual ~A();
int getID() const;
private:
int m_ID;
};
Class B : public A
{
public:
B();
virtual ~B();
int getBid() const;
private:
int m_Bid;
};
bool test(const A* const p_A)
{
if(5U == static_cast<const B* const>(p_A)-&
我将键入一个示例:
class A
{
public:
virtual ~A(){}
};
class B: public A
{
public:
~B()
{
}
};
int main(void)
{
A * a = new B;
delete a;
return 0;
}
现在在上面的例子中,析构函数将从下到上递归调用。我的问题是Compiler是如何做到这一点的。
所以我一直想把头绕在石膏上。在其他语言中,我见过这样的代码
Player player = (DifferentObject as Player)
特别是当涉及到多人游戏,例如。我的问题是,如何在C++中复制这种代码?如果我用
A* a = new B();
每当我想要调用B函数时,我都需要转换A。
struct A
{
A() { }
virtual ~A() { }
void a_only_func() const
{
std::cout << "a only func." << std::endl;
我想为我的Base类初始化一个变量类,并且只在一些子类中修改它。
此类变量的初始化在header中:
class Base{
public:
Base();
int a = 1;
我的派生类的头是:
class ChildA : public Base{
public:
ChildA ();
int a = 2;
}
问题
我试着运行这个:
Base classe*;
classe = new ChildA();
std::cout << classe->a << std::endl;
问题是,它打印的不是我期望的2,而是1 (在父
可能重复:
#include <iostream>
using namespace std;
class B {
public:
virtual void fn1(void) {cout << "class B : fn one \n"; }
virtual void fn2(void) {cout << "class B : fn two \n"; }
};
class D: public B {
void fn1(void) {cout << "class D : fn
假设我有一个类A和一个继承自A的类B,然后我这样做:
A* a = new B();
delete a;
为什么只有在B中存在动态内存分配时才会发生内存泄漏?当B中存在动态内存分配但在B所在位置失败时,C++如何知道删除"B部分“?
更新:
以下代码如何不会导致内存泄漏:我怀疑这是未定义的行为,但我真的什么都不明白:(
#include <iostream>
using std::cout;
using std::endl;
class A {
public:
virtual void f() {
cout << "1"
我有以下代码:
#include <iostream>
using namespace std;
class Base
{
public:
virtual void WhoAmI() const;
typedef void (Base::*WhoPtr)() const;
};
class Derived : public Base
{
public:
virtual void WhoAmI() const;
};
void Derived::WhoAmI() const
{
cout << "I am the der
我知道派生类的类型与指向其基类的指针是兼容的。在给定的示例代码中,new bar对象构造先调用foo::foo(),然后调用bar::bar()。在各自的构造函数中,我将资源分配给类成员foo::int *a和bar::int *b。
现在我正在将这样构造的对象初始化为基类类型。使用obj,我可以调用基类析构函数,但不能调用派生类析构函数。那么,在这种情况下,我如何释放派生类资源呢?这不是内存泄漏吗?
#include <iostream>
class foo
{
int *a;
public:
foo()
{
a = new int[5];
我可能走错路了。我被要求创建一个特定类的对象数组。然而,该类有两个派生类。
class Employee {
// Some stuff here about the backbone of the Employee class
}
class Salary: public Employee {
// Manipulation for Salary employee
}
class Hourly: public Employee {
// Manipulation for hourly Employee
}
// Main Program
int main
#include<iostream>
using namespace std;
class Base
{
public:
void show() { cout<<" In Base \n"; }
};
class Derived: public Base
{
public:
void show() { cout<<"In Derived \n"; }
};
int main(void)
{
Base *bp = new Derived;
bp->show(); // RUN-TIME
如何在内部(运行时期间)决定调用哪个函数(基类或派生类函数)。在下面的示例代码中,如何决定调用fn() of B和fn2() of A。
Class A {
virtual void fn() { std::cout << "A" < <std::endl; }
virtual void fn2() { std::cout << "A-fn2" < <std::endl; }
};
Class B : A
{
void fn() { std::cout << "
当至少有一个类方法是虚的时,每个人都说析构函数应该是虚的。
我的问题是,在使用向上转换时,析构函数应该是虚拟的,这不是正确的吗?
class A {
public:
~A(){
cout << "Destructor in A" << endl;
}
};
class B: public A
{
public:
~B(){
cout << "Destructor in B" << endl;
}
};
int main()
{
A* a
为什么在下面的例子中都调用了析构函数,~D(),~C(),~B(),~A()?
只有一个虚拟析构函数:A的那个。
代码如下:
#include<iostream>
using namespace std;
class A
{
public:
virtual ~A()
{
cout<<"destruct A\n";
}
};
class B:public A
{
public:
~B()
{
cout<<"destruct B\n";
}
};
class C:public B
{
pu