避免“纯虚拟函数调用”在派生类C + + [英] Avoiding "Pure Virtual Function Call" in Derived Class C++

问题描述

我对C ++相当新，所以如果这个问题的级别略低于这里通常的标准，我想表示歉意 -

试图让几个类继承自一个基类有一个虚函数定义，然后我想创建一个MainClass *数组，可以包括所有的派生类，以便输出派生+定义的虚函数。 / p>

我收到错误R6025：纯虚函数调用 - 我不知道为什么，我假设 - 调用时 - 该函数的更新定义

这里是我的代码：

基本：

  class mitarbeiter 
 {
 public：
 mitarbeiter（string name，int nummer）; 
〜mitarbeiter（void）; 
 virtual void einkommen（）= 0; 
 protected：
 string name; 
 int nummer; 
 
}; 
  

Derived1：

 code> #includemitarbeiter.h
 class lohnempfaenger：public mitarbeiter 
 {
 public：
 lohnempfaenger（int stundenlohn，int anzahlStunden，string name，int nummer） ; 
〜lohnempfaenger（void）; 
 void einkommen（）; 
 private：
 int stundenlohn; 
 int anzahlStunden; 
}; 
  

派生2：

  #includemitarbeiter.h
 #include< string> 
 class angestellter：public mitarbeiter 
 {
 public：
 angestellter（int gehalt，string name，int nummer）; 
〜angestellter（void）; 
 void einkommen（）; 
 private：
 int gehalt; 
}; 
 

在Derived 1中执行einkommen（）：

  void lohnempfaenger :: einkommen（）
 {
 cout< Lohnempfaenger，Name：< this-> name<< ，Gesamtlohn：<这 - > stundenlohn * this-> anzahlStunden< \\\
; 
} 
  

在Derived 2中实现einkommen（）：

  void angestellter :: einkommen（）
 {
 cout< Angestellter，Name：< this-> name<< ，Einkommen：<这种gehalt \\\
; 
} 
  

主方法中的阵列声明：

  mitarbeiter * mitPtr [5]; 
 mitPtr [0] =& angestellter（/ * values ... * /）; 
 // error 
 mitPtr [0]  - > einkommen（）; 
  

构造函数：

 code> mitarbeiter :: mitarbeiter（string name，int nummer）
 {
 this-> name = name; 
 this-> nummer = nummer; 
} 
 
 angestellter :: angestellter（int gehalt，string name，int nummer）：mitarbeiter（name，nummer）
 {
 this-> gehalt = gehalt ; 
} 
 
 lohnempfaenger :: lohnempfaenger（int stundenlohn，int anzahlStunden，string name，int nummer）：mitarbeiter（name，nummer）
 {
 this-> stundenlohn = stundenlohn; 
 this-> anzahlStunden = anzahlStunden;非常感谢！
 
 
 h2_lin>解决方案
现在你向我们展示了如何实际初始化指针，这里是问题：
 code> mitPtr [0] =& angestellter（/ * values ... * /）; 
  
指向临时对象，它在语句结尾处销毁。 
 
 
 
您需要一个非临时变量来指向：
  angestellter a（/ * values ... * /）; 
 mitPtr [0] =& a; 
  
或者动态分配的对象：
  mitPtr [0] = new angestellter（...）; 
  
在这种情况下，不要忘记删除它;并且不要忘记给基类一个虚拟析构函数，所以它可以被删除。你可以考虑使用智能指针为你删除它;  std :: unique_ptr 将是理想的。
 
I'm reasonably new to C++ so I'd like to apologize if the level of this question is a little below the usual standards here -

I'm trying to get several classes to inherit from a base class which has a virtual function definition, then I'd like to create an array of MainClass* which can include all of the derived classes in order to output the derived + defined virtual function.

I receive the Error "R6025: pure virtual function call" - I don't know why, I was assuming that - when called - the updated definition of that function from the child classes was used.

Here's my code:

Base:
class mitarbeiter
{
public:
    mitarbeiter(string name, int nummer);
    ~mitarbeiter(void);
    virtual void einkommen() = 0;
protected:
    string name;
    int nummer;

};
Derived1:
#include "mitarbeiter.h"
class lohnempfaenger : public mitarbeiter
{
public:
    lohnempfaenger(int stundenlohn, int anzahlStunden, string name, int nummer);
    ~lohnempfaenger(void);
    void einkommen();
private:
    int stundenlohn;
    int anzahlStunden;
};
Derived 2:
#include "mitarbeiter.h"
#include <string>
class angestellter : public mitarbeiter
{
public:
    angestellter(int gehalt, string name, int nummer);
    ~angestellter(void);
    void einkommen();
private:
    int gehalt;
};
Implementation of "einkommen()" in Derived 1:
void lohnempfaenger::einkommen()
{
    cout << "Lohnempfaenger, Name: " << this->name << ", Gesamtlohn: " << this->stundenlohn*this->anzahlStunden << "\n";
}
Implementation of "einkommen()" in Derived 2:
void angestellter::einkommen()
{
    cout << "Angestellter, Name: " << this->name << ", Einkommen: " << this->gehalt << "\n";
}
Array-Declaration in main method:
mitarbeiter* mitPtr[5];
mitPtr[0] = &angestellter(/*values...*/);
//error
mitPtr[0]->einkommen();
Constructors:
mitarbeiter::mitarbeiter(string name, int nummer)
{
    this->name = name;
    this->nummer = nummer;
}

angestellter::angestellter(int gehalt, string name, int nummer):mitarbeiter(name, nummer)
{
    this->gehalt = gehalt;
}

lohnempfaenger::lohnempfaenger(int stundenlohn, int anzahlStunden, string name, int nummer):mitarbeiter(name, nummer)
{
    this->stundenlohn = stundenlohn;
    this->anzahlStunden = anzahlStunden;
}
Thanks a lot!
解决方案
Now you've shown us how you actually initialise the pointer, here is the problem:
mitPtr[0] = &angestellter(/*values...*/);
That points to a temporary object, which is destroyed at the end of the statement. Using the pointer afterwards will give undefined behaviour.

You'll need a non-temporary variable to point to:
angestellter a(/*values...*/);
mitPtr[0] = &a;
or perhaps a dynamically allocated object:
mitPtr[0] = new angestellter(...);
In that case, don't forget to delete it; and don't forget to give the base class a virtual destructor so it can be deleted. You might consider using a smart pointer to delete it for you; std::unique_ptr would be ideal.

                        
这篇关于避免“纯虚拟函数调用”在派生类C + +的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！