OpenFOAM中operator&重载函数疑问及用法示例求助

Hey there! I totally get why this might feel confusing at first—most of us first learn about operator& as the unary address-of operator, which doesn't take explicit parameters when it's a member function. But let's break down what's going on here.

First: The C++ Background #

In C++, operator& can be overloaded in two distinct ways:

• Unary version: This is the classic "take address" operator, almost always implemented as a member function (so it implicitly uses this as the only operand). You’re right that this version doesn’t take two explicit parameters.
• Binary version: This is a completely valid overload for custom binary operations (just like how + or * are overloaded for custom types). When defined as a non-member function, it requires two explicit parameters—one for each operand. OpenFOAM relies heavily on this kind of operator overloading to create a domain-specific language (DSL) that makes CFD code read more like mathematical equations.

How OpenFOAM Uses Binary operator& #

In OpenFOAM, the binary operator& is often overloaded for types like fvMatrix and volField to implement domain-specific operations. For example, it might:

• Combine a matrix with a field to modify source terms or coefficients
• Apply constraint conditions to a matrix equation
• Perform specialized element-wise operations between two fields

A typical declaration in OpenFOAM's headers might look like this:

template<class Type>
tmp<fvMatrix<Type>> operator&(const fvMatrix<Type>& mat, const volField<Type>& field);

Simple Usage Example #

Let’s walk through a minimal solver example that uses this operator. Suppose we want to modify a temperature equation by adding a source term based on the current temperature field:

#include "fvCFD.H"

int main(int argc, char *argv[])
{
    // Standard OpenFOAM setup boilerplate
    #include "setRootCase.H"
    #include "createTime.H"
    #include "createMesh.H"

    // Load or create temperature field
    volScalarField T
    (
        IOobject
        (
            "T",
            runTime.timeName(),
            mesh,
            IOobject::MUST_READ,
            IOobject::AUTO_WRITE
        ),
        mesh
    );

    // Diffusion coefficient field
    volScalarField k("k", dimensionedScalar(dimThermalConductivity, 0.1), mesh);

    // Build the base temperature equation
    fvScalarMatrix TEqn
    (
        fvm::ddt(T) - fvm::laplacian(k, T) == dimensionedScalar(dimEnergy/dimTime, 0.0)
    );

    // Use operator& to modify the equation: add diag(TEqn) * T to the source term
    tmp<fvScalarMatrix> modifiedTEqn = TEqn & T;

    // Solve the modified equation
    modifiedTEqn->solve();

    // Write the updated temperature field
    T.write();

    return 0;
}

In this example, TEqn & T invokes the binary operator& overload, which modifies the source term of the original matrix equation using the current temperature values.

Key Takeaway #

The confusion comes from mixing up the unary address-of operator and the binary custom operator. OpenFOAM's two-parameter operator& is a valid binary overload designed to make CFD code more intuitive and concise. Its exact behavior depends on the specific types it's overloaded for—always check the header file or OpenFOAM documentation for the implementation details of the overload you're working with.

内容的提问来源于stack exchange，提问作者Xiongguo Liu