openfoam文件读取，usingnames

#include <iostream>         // 包含头文件。

using namespace std;        // 指定缺省的命名空间。

int main()
{
    int a = 10;
    int b = (10);
    int c(10);
    int e = {10};
    int f{ 10 };

    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
    cout << "c=" << c << endl;
    cout << "e=" << e << endl;
    cout << "f=" << f << endl;
}

#include <iostream>
#include <fstream>  // ifstream类需要包含的头文件。
#include <string>     // getline()函数需要包含的头文件。
using  namespace std;

int main()
{
    string filename = R"(./test.txt)";

    //ifstream fin(filename, ios::in);
    ifstream fin;
    fin.open(filename , ios::in);

    // 判断打开文件是否成功。
    // 失败的原因主要有：1）目录不存在；2）文件不存在；3）没有权限，Linux平台下很常见。
    if (fin.is_open() == false)
    {
        cout << "打开文件" << filename << "失败。\n";  return 0;
    }

    string buffer;
    while (fin >> buffer)
    {
        cout << buffer << endl;
    }

    fin.close();	   // 关闭文件，fin对象失效前会自动调用close()。

    cout << "操作文件完成。\n";
}

class IOdictionary
:
    public baseIOdictionary
{

public:

    // Constructors

        //- Construct given an IOobject
        IOdictionary(const IOobject&);

        //- Construct given an IOobject and dictionary
        IOdictionary(const IOobject&, const dictionary&);

        //- Construct given an IOobject and Istream
        IOdictionary(const IOobject&, Istream&);

        //- Copy constructor
        IOdictionary(const IOdictionary&);

        //- Move constructor
        IOdictionary(IOdictionary&&);


    //- Destructor
    virtual ~IOdictionary();


    // Member Functions

        //- Is object global
        virtual bool global() const
        {
            return true;
        }

        //- Return complete path + object name if the file exists
        //  either in the case/processor or case otherwise null
        virtual fileName filePath() const
        {
            return globalFilePath(type());
        }


    // Member Operators

        //- Move assignment
        void operator=(IOdictionary&&);
};

        //- Enumeration defining the valid states of an IOobject
        enum objectState
        {
            GOOD,
            BAD
        };

        //- Enumeration defining the read options
        enum readOption
        {
            MUST_READ,
            MUST_READ_IF_MODIFIED,
            READ_IF_PRESENT,
            NO_READ
        };

        //- Enumeration defining the write options
        enum writeOption
        {
            AUTO_WRITE = 0,
            NO_WRITE = 1
        };

        //- Enumeration defining the file checking options
        enum fileCheckTypes
        {
            timeStamp,
            timeStampMaster,
            inotify,
            inotifyMaster
        };

    // Constructors

        //- Construct from name, instance, registry, io options
        IOobject
        (
            const word& name,
            const fileName& instance,
            const objectRegistry& registry,
            readOption r=NO_READ,
            writeOption w=NO_WRITE,
            bool registerObject=true
        );

        //- Construct from name, instance, local, registry, io options
        IOobject
        (
            const word& name,
            const fileName& instance,
            const fileName& local,
            const objectRegistry& registry,
            readOption r=NO_READ,
            writeOption w=NO_WRITE,
            bool registerObject=true
        );

        //- Construct from path, registry, io options
        //  Uses fileNameComponents() to split path into components.
        IOobject
        (
            const fileName& path,
            const objectRegistry& registry,
            readOption r=NO_READ,
            writeOption w=NO_WRITE,
            bool registerObject=true
        );

        //- Construct from copy resetting registry
        IOobject
        (
            const IOobject& io,
            const objectRegistry& registry
        );

        //- Construct from copy resetting name
        IOobject
        (
            const IOobject& io,
            const word& name
        );

        //- Copy constructor
        IOobject(const IOobject& io) = default;

IOobject dicName(
    "dicName",
    runTime.timeName(),
    //runTime.constant(),
    mesh,
    IOobject::MUST_READ,
    IOobject::AUTO_WRITE
) ;

    IOdictionary dicName(
        IOobject (
            "dicName",
            //runTime.constant(),
            runTime.system(),
            mesh,
            IOobject::MUST_READ,
            IOobject::AUTO_WRITE
        )
    ) ;

    volVectorField U(
        IOobject(
            "U" ,
            runTime.timeName() ,
            mesh ,
            IOobject::MUST_READ ,
            IOobject::AUTO_WRITE
        ) ,
        mesh
    );
    volScalarField p(
        IOobject(
            "p" ,
            runTime.timeName() ,
            mesh ,
            IOobject::MUST_READ ,
            IOobject::AUTO_WRITE
        ) ,
        mesh
    );

    IOdictionary controlDict(
        IOobject (
            "controlDict",
            runTime.constant(),
            //runTime.system(),
            mesh,
            IOobject::MUST_READ,
            IOobject::AUTO_WRITE
        )
    ) ;

//***********************************************//
	//openfoam
	"Foam_IOobject": {
		"prefix": "IOobject_Foam_",
		"body": [
			"IOobject ${1|U,p,T,dicName|}(",
			// "\t${2|\"U\",\"p\",\"T\"|}",
			"\t\"${1}\",",
			"\t//runTime.timeName(),",
			"\t//runTime.constant(),",
			"\tmesh,",
			"\tIOobject::MUST_READ,",
			"\tIOobject::AUTO_WRITE",
			") ;"
		],
		"description": "FOAM::IOobject"
	},
	"Foam::IOdictionary": {
		"prefix": "IOdictionary_Foam_",
		"body": [
			"IOdictionary ${1:dicName}(",
			"\tIOobject (",
			// "\t${2|\"U\",\"p\",\"T\"|}",
			"\t\t\"${1}\",",
			"\t\t//runTime.constant(),",
			"\t\t//runTime.system(),",
			"\t\tmesh,",
			"\t\tIOobject::MUST_READ,",
			"\t\tIOobject::AUTO_WRITE",
			"\t)",
			") ;"
		],
		"description": "Foam::IOdictionary"
	},
	"Foam::volVectorField": {
		"prefix": "volVectorField_Foam_",
		"body": [
			"volVectorField ${U}(",
			"\tIOobject (",
			"\t\t\"${U}\",",
			"\t\trunTime.timeName(),",
			"\t\tmesh,",
			"\t\tIOobject::MUST_READ,",
			"\t\tIOobject::AUTO_WRITE",
			"\t),",
			"\tmesh",
			") ;"
		],
		"description": "Foam::volVectorField"
	},
	"Foam::volScalarField": {
		"prefix": "volScalarField_Foam_",
		"body": [
			"volScalarField ${p}(",
			"\tIOobject (",
			"\t\t\"${p}\",",
			"\t\trunTime.timeName(),",
			"\t\tmesh,",
			"\t\tIOobject::MUST_READ,",
			"\t\tIOobject::AUTO_WRITE",
			"\t),",
			"\tmesh",
			") ;"
		],
		"description": "Foam::volScalarField"
	},
	"Foam::scalar": {
		"prefix": "scalar",
		"body": [
			"scalar "
		],
		"description": "Foam::scalar"
	},
	//***********************************************//