OpenFOAM中虚函数、继承和forAllConstIter()函数

虚函数，在派生类中初始化基类

提示：这里对OpenFOAM文件内applications/test/callback文件的注释与改动

---

前言

提示：首先你要知道了解继承，类的初始化方式（构造函数的几种类型），多态中的虚函数

我的理解是构造函数依据写的形式包括：内联型（初始化列表形式）、复制型、委托型好像还有。
虚函数是为基类和派生类中都写同名同参函数所准备的。

---

一、注释代码

提示:代码中有很多输出，仅仅是为了清楚进入了那个函数，清楚编译流程。类似于单步调试

代码如下（示例）：

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
     \\/     M anipulation  |
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.

    You should have received a copy of the GNU General Public License
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.

Application
    callBackTest

Description

\*---------------------------------------------------------------------------*/
/*callback类需要一个CallbackRegistry基类对象来初始化，但没有，所以就定义了个继承CallbackRegistry基类的派生类
来初始化callback类。*/
/*当派生类和基础类中都存name()函数，如果不设置虚函数，则仅仅使用基类中的name()；如果设置了虚函数，会根据
对象所属于的类去判断使用那一个name()函数。
在此程序中还展示了，通过派生类去初始化基类。
此程序还展示了，openfoam中使用的forAllConstIter(Container,container,iter),我认为是遍历同一种类的所有对象。*/
#include "Callback.H"

using namespace Foam;

class callback
:
    public Callback<callback>
{
public:

    callback(CallbackRegistry<callback>& cbr) //h构造函数，通过初始化列表的形式
    :
        Callback<callback>(cbr)
    {}

    ~callback()
    {}

    virtual const word& name() const //虚函数
    {
        Info<<"null"<<endl;
        return word::null;
        
    }
 
    void testCallbackFunction() const
    {
        Info<< "calling testCallbackFunction for object :" << name() << endl;
        Info<<"11"<<endl;
    }
};

//定义callbackRegistry的目的是给callback的初始化
class callbackRegistry
:
    public CallbackRegistry<callback>
{
public:

    callbackRegistry()
    {}

    ~callbackRegistry()
    {}

    void testCallbackFunction() const
    {
        Info<<"进入继承类中的函数callback::testCallbackFunction()"<<endl;
/*  #define forAllConstIter(Container,container,iter)                              \
    for                                                                        \
    (                                                                          \
        Container::const_iterator iter = (container).begin();                  \
        iter != (container).end();                                             \
        ++iter                                                                 \
    )*/
        forAllConstIter(callbackRegistry,*this, iter) //遍历所有的*this
        {
            Info<<">"<<endl;
            Info<<"iter的类型："<<typeid(iter()).name()<<endl;
            iter().testCallbackFunction();//iter在这里是objectWithCallback类型的对象，
            //所以他才会去callback::testCallbackFunction


            Info<<"?"<<endl;
        }
    }
};


class objectWithCallback
:
    public callback
{
    word name_;

public:

    objectWithCallback(const word& n, callbackRegistry& cbr)
    :
        callback(cbr),//给基类初始化，（把参数回调到基类）
        name_(n)
    {}

    virtual const word& name() const
    {
        Info<<"objectWithCallback"<<endl;
        return name_;
        
    }
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:

int main(int argc, char *argv[])
{


    callbackRegistry cbr;

    callback op(cbr);//生成一个名为op的对象
    Info<<"callback"<<endl;
    Info<<"op的类型"<<typeid(op).name()<<endl;
    Info<<op.name()<<endl;//因为name里面也存在一个换行，所以有两个换行
    Info<<"callback"<<endl;
   
    objectWithCallback ob1("ob1", cbr);//构造函数，生成名为ob1的对象
    Info<<ob1.name()<<endl;
    Info<<"ob1的类型:"<<typeid(ob1).name()<<endl;
    objectWithCallback ob2("ob2", cbr);
    Info<<ob2.name()<<endl;

    cbr.testCallbackFunction();//进入继承类中的函数
    Info<<"3"<<endl;
    {
        objectWithCallback ob1("ob1", cbr);
        Info<<"4"<<endl;
        cbr.testCallbackFunction();
        Info<<"5"<<endl;
    }

    cbr.testCallbackFunction();

    Info<< "End\n" << endl;

    return 0;
}


// ************************************************************************* //

二、结果

1.引入库

代码如下（示例）：

tsing@tsing:~$ Test-callback 
callback
op的类型8callback
null

callback
objectWithCallback
ob1
ob1的类型:18objectWithCallback
objectWithCallback
ob2
进入继承类中的函数callback::testCallbackFunction()
>
iter的类型：8callback
calling testCallbackFunction for object :null

11
?
>
iter的类型：18objectWithCallback
calling testCallbackFunction for object :objectWithCallback
ob1
11
?
>
iter的类型：18objectWithCallback
calling testCallbackFunction for object :objectWithCallback
ob2
11
?
3
4
进入继承类中的函数callback::testCallbackFunction()
>
iter的类型：8callback
calling testCallbackFunction for object :null

11
?
>
iter的类型：18objectWithCallback
calling testCallbackFunction for object :objectWithCallback
ob1
11
?
>
iter的类型：18objectWithCallback
calling testCallbackFunction for object :objectWithCallback
ob2
11
?
>
iter的类型：18objectWithCallback
calling testCallbackFunction for object :objectWithCallback
ob1
11
?
5
进入继承类中的函数callback::testCallbackFunction()
>
iter的类型：8callback
calling testCallbackFunction for object :null

11
?
>
iter的类型：18objectWithCallback
calling testCallbackFunction for object :objectWithCallback
ob1
11
?
>
iter的类型：18objectWithCallback
calling testCallbackFunction for object :objectWithCallback
ob2
11
?
End

总结

玩OpenFoam C++基础很重要。