0

I have a class GenericNode which is inherited by ValueNode and OperatorNode. OR_Node inherits OperatorNode.

#include <iostream>
#include <vector>

template< typename T_Value >
class GenericNode
 {
public: 
GenericNode() {} ;
virtual ~GenericNode() {} ;
// virtual T_Value evaluate() { std::cout << "BAD I'm abstract, who call me?" << std::endl ;} ;
virtual T_Value evaluate() = 0 ;
} ;

template< typename T_Value >
class ValueNode : public GenericNode<T_Value>
{
public:
ValueNode() {} ;
ValueNode( T_Value arg0 )
{
    this->aValue = arg0 ;
}
void setValue( T_Value arg0 )
{
    this->aValue = arg0 ;
}
~ValueNode() {} ;
 protected: 
T_Value aValue ;
public: 
virtual T_Value evaluate()
{
    return this->aValue ;
}
 } ;

 template< typename T_Value >
class OperatorNode : public GenericNode<T_Value>
{
public:
OperatorNode() {} ;

OperatorNode( GenericNode<T_Value>* arg0 , GenericNode<T_Value>* arg1 )
{
    std::cout << "aValue: " << arg0->evaluate() << std::endl ;
    std::cout << "aValue: " << arg1->evaluate() << std::endl ;
    this->left = arg0 ;
    this->right = arg1 ;
    std::cout << "aValue: " << this->left->evaluate() << std::endl ;
    std::cout << "aValue: " << this->right->evaluate() << std::endl ;
}
virtual T_Value evaluate() { std::cout << "BAD I'm abstract OperatorNode, who call me?" << std::endl ;} ;
virtual ~OperatorNode() {} ;
//protected:    
GenericNode<T_Value>* left ;
GenericNode<T_Value>* right ;

} ;

template< typename T_Value >
class OR_Node : public OperatorNode<T_Value>
{
public:
~OR_Node() {} ;
OR_Node( GenericNode<T_Value> *arg0 , GenericNode<T_Value> *arg1 )
{
    OperatorNode<T_Value>( arg0 , arg1 ) ;
}
public: 
virtual T_Value evaluate()
{
    std::cout << "ok here " << std::endl ;

    std::cout << "-> " << this->left->evaluate() << std::endl ;

    //return this->left->evaluate() + this->right->evaluate() ;
}
} ;
int main()
 {
 std::vector< GenericNode< int >* > myVec ;
 ValueNode<int> One , Two , Three , Four , Five ;
 One.setValue( 1 ) ;
 Two.setValue( 2 ) ;
 Three.setValue( 3 ) ;
 Four.setValue( 4 ) ;
 Five.setValue( 5 ) ;
 OR_Node<int> orOne( &Three , &Four ) ;

 //std::cout << "----> " << orOne.evaluate() << std::endl ;
 myVec.push_back( &orOne ) ;

 myVec.push_back( &One ) ;
 myVec.push_back( &Two ) ;
 myVec.push_back( &Three ) ;
 myVec.push_back( &Four ) ;
 myVec.push_back( &Five ) ;


// ValueNode< int > aVN( 1 ) ;
   while (!myVec.empty())
    {
        std::cout << "-> " << myVec.back()->evaluate() << std::endl ;
        myVec.pop_back();
    }



return 0 ;
}

The output is:

aValue: 3
aValue: 4
aValue: 3
aValue: 4
-> 5
-> 4
-> 3
-> 2
-> 1
ok here 
Segfault

I do not understand why the line of code:

std::cout << "aValue: " << this->left->evaluate() << std::endl ;

works fine, and the line

std::cout << "-> " << this->left->evaluate() << std::endl ;

produces a segfault.

Thanks! :D

4

2 に答える 2

4 
OR_Node( GenericNode<T_Value> *arg0 , GenericNode<T_Value> *arg1 )
{
    OperatorNode<T_Value>( arg0 , arg1 ) ;
}

このコード：

  1. 基本クラスのデフォルトコンストラクターを呼び出しますOperatorNode<T_Value>
  2. タイプの別の一時オブジェクトを構築し、それOperatorNode<T_Value>に渡します。arg0arg1
  3. その一時的なものを破棄します。

OperatorNode<T_Value>したがって、内のメンバーOR_Node<T_Value>はまだ初期化されていないポインタです。

基本クラスのサブオブジェクトを初期化する正しい方法は、メンバー初期化子リストを使用することです。

OR_Node( GenericNode<T_Value> *arg0 , GenericNode<T_Value> *arg1 )
    : OperatorNode( arg0, arg1 )
{
}
于 2013-02-06T19:05:34.917 に答える
0

私はGHLに同意します、あなたは空のスタックをポップしようとしています。スタックをチェックして、最初に空であるかどうかを確認し、空になる場合は、例外をスローするか、終了します。

于 2013-02-06T19:05:48.180 に答える