Can a class contain a blank function that can be loaded via a method?

Currently, I am writing a code for scientific computation. I want to make a class of the MHD_Model, like so:

class MHD_Model{
    private:
    double position;
    double boundary_condidtion;
    double magnetic_field;
    public:
    // constructor, methods for setting the boundary condititon etc.
}

For now, double magnetic_field; is a number, however I need to make it a function of position. I imagine it this way, first I define the magnetic field like e.g.:

double Bfield(double x){
    return x*x;
}

and then write a method called double MHD_Model::load_magnetic_field() which will take a function Bfield as input. However, I can’t make it work, and I started to suspect this isn’t the right way to do so.

I am not a programmer by training but a physicist. I need to learn C++/other fast programming language as I started a PhD now and will be dealing with computation-heavy stuff.

I tried writing the function Bfield as pass by reference, pass by value, and using const double position within the class, but nothing compiles. I understand the errors (most of them are kind of like: binary operator / can’t be used for types double and (double *) double). The main problem is that I don’t know the “correct” way of writing such behaviour, and I am not sure if that’s allowed the way I imagined the program to be structured.

Can someone suggest anything or point me to a resource on this? I know the best way would be to learn C++, but I am short on time.

BTW, my supervisor is not programming either, so I can’t refer to him; he’s only using Wolfram Mathematica.

EDIT:

I’m including what I programmed so far on how I imagine it would work:

main.cpp

#include <bits/stdc++.h>
#include <cmath>
#include <vector>
#include <print>

#include "mhd.hpp"

using namespace std;

double b(double *x){
  return 1./ &x;
}


int main(){

  double q = 10.;
  double x = .3;
  MHDModel model;
  model.set_equipartition(q);
  model.set_position(x);
  model.load_magnetic_field(&b);

  return 0;

}

mhd.cpp

#include "mhd.hpp"

#include <iostream>



void MHDModel::set_equipartition(double q) {
  equipartition = q;
  std::cout << "Setting equipartition parameter to " << q << "...n";
};

void MHDModel::set_position(double x){
  jet_position=x;
};

void MHDModel::load_magnetic_field(double b){
  jet_mag_field = b;
};

mhd.hpp

#ifndef MHD_HPP
#define MHD_HPP

#include <iostream>

class MHDModel{
  private:
    double jet_position;
    double jet_mag_field;
    double equipartition;
  public:
    MHDModel(double x = 0., double q = 1.){
      jet_position = x;
      equipartition = q;
      std::cout << "Creating magnetohydrodynamic model..." << "n";
    };
  void set_equipartition(double q);
  void set_position(double x);
  void load_magnetic_field(double b);
};

#endif // !MHD_HPP

While I am aware that it shouldn’t work, I have no idea how it would be done. It’s kind of hard to research that, as everything concerning “load function into class” etc is about methods, which is kind of not the case here (I think?).

New contributor

Yes you can use a std::function to inject a function into your model like this :

// #include <bits/stdc++.h> <== NEVER include this... it is not standard C++
#include <functional>
#include <iostream>

// do NOT use `using namespace std;`

double b(double x) // No need to pass double as a pointer
{
    std::cout << "b calledn";
    return 1.0 / x;
}


class Model
{
public:
    Model(std::function<double(double)> fn) :
        m_fn{ fn }
    {

    }

    double calculate(double v)
    {
        return m_fn(v);
    }

private:
    std::function<double(double)> m_fn;
};

int main()
{
    Model model{ b };
    model.calculate(1.0);
}

I use std::function because that allows you to inject lambda expressions with
captures too.

use can use a function pointer in the argument of your load_magnetic_field method

double MHD_Model::load_magnetic_field(double (*func)(double *x)) {
    double x = 1.0;
    return func(&x); // Call the function using the pointer
}

and then if you want to store such pointer withing the class

private:
    double (*stored_function)(double *x);

and to assign a pointer during a method call

stored_function = func;

we can also declare a function type to avoid having a full declaration in every use of it

typedef double (*FuncType)(double *x);

or in modern style

using FuncType = double (*)(double *x);

in that case the class member will look like that

private:
 FuncType stored_function;

and passing in argument looks like that

load_magnetic_field(FuncType func)

In addition to setting a function pointer or std::function at run time, there are several other ways to achieve your desired result. No one is absolutely better or worse than any of the others, choose one that works better in your particular settings. Here’s a couple:

template <auto MagneticFieldFunction>
class MHD_Model { ...
}; 

...

MHDModel<b> myModel;

class MHD_Model {
  ...
  virtual double magnetic_field(double) = 0;
}

class Squares_MHD_Model : public MHD_Model {
  double magnetic_field(double x) final override {
    return x*x;
  }
}

...

Squares_MHD_Model myModel;

These versions are potentially ever so slightly more efficient than the ones that use function pointers or std::function, but also are potentialy more restrictive, depending on how exactly you plan to use your model objects.

Filed under: Kiến thức lập trình - @ 02:41

Thẻ: c++

Thiết kế website giá rẻ

Danh mục

Can a class contain a blank function that can be loaded via a method?