虚函数多态与继承

时间:2015-03-23 08:55:02

标签: c++ pointers polymorphism virtual

我知道标题很糟糕......但我不知道我手上有什么实际问题......

我已经为链表和一个继承基类的专用类定义了一个基类。

基地:

list.h

#ifndef LIST_H
#define LIST_H

#include <string>
#include "../../declarations.h"
#include "element.h"

class List: public Element{
/*
 * @brief is a generic list class, designed to be inherited by more
 * specialised list emulating classes.
 */

    public: // methods

        /// generates empty list.
        List(){
            init();
            cout << "defining List" << endl;
        }

        /// Removes first list element
        bool remove_first(){

            if (!is_empty()){
                Element* newFirst = first;
                delete first;
                first = newFirst->next;
                return true;
            }
            else{
                std::cerr << "list already empty" << endl;
                return false;
            }
        }

        /// removes last list element
        bool remove_last(){

            // store length fo list in min_len for switch
            unsigned int min_len = 0;
            if (!is_empty()){
                if ((first->next) != 0){
                    min_len = 2;
                }
                else {
                    min_len = 1;
                }
            }
            // as switch doesn't allow for comparisons, map any value greater
            // 1 to 2       if (min_len>1) min_len = 2;
            switch (min_len){
                case (2):{
                    // Iterate over list, always look two elements ahead.
                    // If the next element points to 0 you have found your new last
                    // element (the current next to last one). Delete current-> next
                    // to remove the last element and let the new last one point to
                    // zero.
                    Element* current = first;
                    while((current->next)->next != 0){
                        current = (current->next);
                    }
                    delete (current->next);
                    current->next = 0;
                    return true;
                }
                // if the list contaisn only one element use remove_first()
                // as the logic for that case is already present there
                case (1): return remove_first();
                case (0):{
                    std::cerr << "list already empty" << endl;
                    return false;
                }
            }
        }

        // Declare several virtual functions for appending elements
        // that get defined in the iheriting classes.
        virtual void append_front(int i){};
        virtual void append_front(char c){};
        virtual void append_front(std::string s){};

        virtual void append_back(int i){};
        virtual void append_back(char c){};
        virtual void append_back(std::string s){};


        /// todo
        std::string head(){}

        /// returns length of list
        unsigned length(){

            unsigned counter = 0;
            Element* current = first;

            while(current != 0) {
                ++counter;
                current = current->next;
            }
            return counter;
        }

        /// determines whether list is empty
        bool is_empty(){
            return first == 0;
        }

        // printing depends on type of list, so this method gets defined in
        // inheriting class
        virtual void print(){};


    private: // methods

        void init(){
            // initialise empty list with a NULL pointer
            first = 0;
        }

    protected: // data members

        /// points to first list element or zero, if list is empty
        Element* first;
};

#endif

派生:

transitionsList.h

#ifndef TRANSITION_LIST_H
#define TRANSITION_LIST_H

#include "../../../generic/list.h"
#include "../../elements/transition/transition.h"

class TransitionList: public List {

    public:

        void append_front(char c){

            // generate list element and store in pointer e
            Element* e;
            e = new Transition();
            // store parameter c in the object *e points to
            e->set_content(c);
            // Either list is empty. In thet case object at &e becomes first
            // list element and also the last.
            // Or list wasn't empty and e->next points to the current first, then
            // object *e points to becomes first.
            if (is_empty()) {
                first = e;
                e->next = 0;
            }
            else {
                e->next = first;
                first = e;
            }
        }


        void append_back(char c){

            if (is_empty()) {
                append_front(c);
            }
            else {
                Element* e;
                e = new Transition();
                e->set_content(c);
                e->next = 0;
                // Go through the list until you find the last element, let it
                // then ppint to the new last element.
                Element* current = first;
                while(current->next != 0) {
                    current = current->next;
                }
                current->next = e;
            }
        }


        void print(){

            cout << "[";
            // go through the list, starting with first element
            Element* current = first;
            // as long as the last list element is not the current one, keep
            // printing elements.
            while (current != 0) {
                cout << " " << current->get_content();
                // let current be the next of current current, to move
                // through the list
                current = current->next;
            } // while
            cout << " ]";
        }
};

#endif

这两个依赖于其他几个类:

element.h展开:

#ifndef ELEMENT_H
#define ELEMENT_H

#include "../../declarations.h"


class State;

class Element{
/*
 * @brief is a generic list element class, designed to be inherited by
 *  more specialised list element classes.
 */
    public:

        Element(){}

        virtual ~Element(){}

        virtual void set_content(int i){};
        virtual void set_content(char c){};
        virtual void set_content(std::string s){};

        virtual char get_content() = 0;


        Element* next;  ///< is the pointer to the next transition in the list

};

#endif

state.h:

#ifndef STATE_H
#define STATE_H

#include "../../declarations.h"

class List;

class State{
/**
 * @brief is a class emulating a trie state
 */

    public: // methods

        State(){
            cout << "defining State" << endl;
            init();
        }

    private: // methods

        void init(){

        }

    private: // variables

        // Pointer required due to forward declarations
        List* transitions; ///< is the list of states dominated by THIS.
        // count stores how often the word the current path codes for has been
        // found in the training data.
        int count; ///< is the number of occurances of some word in this path.

};

#endif

和transition.h

#ifndef TRANSITION_H
#define TRANSITION_H

#include "../../../generic/element.h"
#include "../../state.h"

typedef char cont;

class Transition: public Element {
public:

    void set_content(cont c){
        content = c;
    };

    cont get_content(){
        return content;
        };

    State* successor;
    Transition* next;  ///< is the pointer to the next transition in the list

protected:

    cont content; ///< is the character this transition codes for

};

#endif

当我现在运行这个cpp文件时:

list_test.cpp:

#include "transitionList.h"

int main(){
    TransitionList* derivedList;
    List *baseList = &derivedList;
}

我收到错误:

list_test2.cpp:5:8: error: cannot initialize a variable of type 'List *' with an rvalue of type 'TransitionList **'

我不理解,因为我(显然是假的)印象,这与我在本教程中看到的类似:

https://youtu.be/DudHooleNVg?t=4m59s

在哪里

int main(){
        TransitionList* derivedList;
        List *baseList = &derivedList;
}

不相似
int main(){
        Ninja* n;
        Enemy *enemy1 = &n;
}

:/非常困惑。

0 个答案:

没有答案