虚函数必须定义（纯虚函数除外）

1. 虚函数的声明和定义
具体关于虚函数的知识不做多讲，我在定义一个抽象类时，忘了将一个虚函数声明为 纯虚函数，又没有对其定义， 导致编译报错时报错如下：
undefined reference to `vtable for Fibonacci'
错误提示的很明显，就是无法生成虚函数表。


我们知道，虚函数表(地址)在定义了虚函数的类所实例化的对象内存中的第一个位置，也就是在实例化过程中生成了虚表。这个错误提示在stackflow中最常见的解答就是类中声明了虚函数，却没有定义。

总结一下虚函数声明和定义的规则如下：

类中的virtual函数，要么设为纯虚函数，要么有定义，否则无法生成虚函数表。

虚函数的可以类外定义，但是必须加上类名，类外定义不需要加virtual
声明为纯虚函数，则类为抽象类，无法实例化，进一步强调，想要实例化有虚函数的类，必须对虚函数进行定义
基类定义为虚函数，则子类同名函数也为虚函数，无论是否有virtual关键字修饰(一般声明时加virtual，便于阅读)


凡是基类定义有虚函数，则基类需要定义虚析构函数(根据上一条法则，虚析构函数要么有定义，要么纯虚，一般不设为纯虚，可以定义空白)
虚函数通过虚表实现，虚表是类实例化时生成在对象中的(虚表地址)，所以如果一个类能够实例化，则其虚函数必须有定义，如果不想定义虚函数，只能声明为纯虚函数，留给子类定义。

基类为一个抽象类

// num_sequence.h
#ifndef _NUM_SEQUENCE


#define _NUM_SEQUENCE


#include <string>
#include <iostream>


using namespace std;


class num_sequence {


    public:
        num_sequence() {
            cout << " create a num sequence" << endl;
        }


        virtual ~num_sequence() {
            cout << "~num_sequence has been called" << endl;
        }  


        virtual int elem(int pos) const= 0;
        virtual const string what_am_i() const = 0;


        static int max_elems(){
            return  _max_elems;
        }


        virtual ostream& print(ostream& = cout) const = 0;


    protected:
        virtual void gen_elems(int pos) const = 0;      // const指针指向自认为const的一个对象, 这个对象不能通过const指针进行修改, 但可以通过其他方式进行修改


        bool check_integrity(int pos) const{
            if(pos <=0 || pos >_max_elems) {
                cerr << "Invalid position: " << pos << endl;
                return false;
            }
            return true;
        }


        const static int _max_elems = 1024;         // 最大元素个数
};


#endif

子类不是抽象类，则必须实现基类的纯虚函数


子类声明：


// Fibonacci.h


#ifndef _FIBONACCI


#define _FIBONACCI


#include "num_sequence.h"
#include <vector>


using std::vector;


class Fibonacci : public num_sequence {


    public:
        Fibonacci(int len = 1, int beg_pos = 1): _length(len), _beg_pos(beg_pos){
            cout << "create a Fibonacci sequence" << endl;
        }


        virtual int elem(int pos) const ;    // 子类类中声明virtual时, 应当和父类保持精确一致性


        virtual ostream& print(ostream &os=cout) const;


        virtual const string what_am_i() const{
            cout << " I am Fibonacci sequence" << endl;
        }




        int length() const {
            return _length;
        }


        int beg_pos() const{
            return _beg_pos;
        }


        ~Fibonacci() {
            cout << "~Fibonacci has been called" << endl;
        }


    protected:
        virtual void gen_elems(int pos) const;


        int                 _length;    // 长度
        int                 _beg_pos;   // 起始位置
        static vector<unsigned int>  _elems;     // 元素容器


};

#endif

子类虚函数定义：


// Fibonacci.cpp


#include "Fibonacci.h"


vector<unsigned int> Fibonacci::_elems;


// 类外定义virtual函数时, 不需要virtual关键字
int Fibonacci::elem(int pos) const {


    if(!check_integrity(pos))           // 检查pos可用性
        return 0;


    if(pos > _elems.size() )            // 检查当前元素个数是够足够, 当不足时自动生成
        Fibonacci::gen_elems(pos);      // 利用类作用域, 在编译时指明调用函数  


    return _elems[pos - 1];
}


ostream& Fibonacci::print(ostream &os) const {


    int elem_pos = _beg_pos - 1;
    int end_pos = elem_pos + _length;


    if(end_pos > _elems.size()) {
        Fibonacci::gen_elems(end_pos);
    }


    while(elem_pos < end_pos) {
        os << _elems[elem_pos] << "\t";
        ++elem_pos;
    }
    return os;
}


void Fibonacci::gen_elems(int pos) const {


    if(_elems.empty()) {
        _elems.push_back(1);
        _elems.push_back(1);
    }


    if(_elems.size() <= pos) {
        int ix = _elems.size();
        int n_2 = _elems[ix-2];
        int n_1 = _elems[ix-1];


        for(; ix<=pos; ++ix){
            int elem = n_2 + n_1;
            _elems.push_back(elem);
            n_2 = n_1;
            n_1 = elem;
        }
    }

}

http://blog.youkuaiyun.com/gvfdbdf/article/details/51954819