C ++將指針數組傳遞給函數指針數組時遇到麻煩

Question

數組指針ODE [3]可訪問以下3個函數：

double voltage(double v) {
    return Iapp - (gL*(v - EL)) - (gNa * pow(m, 3) * h * (v - ENa)) - (gK * pow(n, 4) * (v - EK));
}

double hdot(double h) {
    ah = 0.07*exp(-(v + 58) / 20);
    bh = 1 / (exp(-0.1*(v + 28)) + 1);
    return (phi * (ah*(1 - h) - bh*h));
}
double ndot(double n) {
    an = -0.01*(v + 34) / (exp(-0.1*(v + 34)) - 1);
    bn = 0.125 * exp(-(v + 44) / 80);
    return (phi * (an*(1 - n) - bn*n));
}

typedef double(*eqpointer)(void);
eqpointer ODE[3];

這樣

ODE[0] = voltage;
ODE[1] = hdot;
ODE[2] = ndot;

在另一個函數中， midvalues ， oneloop和k1是指向數組的指針。

for (int j{ 0 }; j <= eq_num; ++j) k1[j] = dt*(ODE[j]());

for (int j{ 0 }; j <= eq_num; j++) midvalues[j] = oneloop[j] + k1[j] / 2;

我想實現一個循環：

for (int j{ 0 }; j <= eq_num; j++) ODE[j](midvalues[j]);

這樣每個函數ODE [j]都將相應的指針midvalues [j]作為參數。

我猜我需要兩個指針的函數，一個不帶參數並返回值，即： ODE[j]() ，另一個帶指針位置作為參數並返回值。

我一直在努力尋找如何做到這一點的方法，希望對您有所幫助。 提前致謝 ：）

Answer 1

C ++的變體：

 #include <iostream>
    using namespace std;

    double voltage(double v) {
        return v;
    }
    double hdot(double h) {
        return h * 2;
    }
    double ndot(double n) {
        return n * 3;
    }

    typedef double(*eqpointer)(double);

int main() {
    eqpointer ODE[] = { voltage, hdot, ndot };
    int eq_num = sizeof(ODE) / sizeof(*ODE); // quantity elements in ODE[]
    double *midvalues = new double[eq_num]; //change to variant (ty M_M)

    for (int j = 0; j < eq_num; j++) {
        midvalues[j] = (*ODE[j])((j + 1) * 10) / 2;  // Value For Example
        printf("midvalues[%d]: %f\n", j, midvalues[j]);
    }
    return 0;
}

標准輸出

*** midvalues[0]: 5.000000<br>
*** midvalues[1]: 20.000000<br>
*** midvalues[2]: 45.000000<br>

愛迪生

std :: vector的變體（@MM）

#include <iostream>
#include <vector>
    using namespace std;

    double voltage(double v) {
        return v;
    }
    double hdot(double h) {
        return h * 2;
    }
    double ndot(double n) {
        return n * 3;
    }

    typedef double(*eqpointer)(double);

int main() {
    vector<eqpointer> ODE = { voltage, hdot, ndot };
    int eq_num = ODE.size(); // quantity elements in ODE[]
    vector<double> midvalues(eq_num);
    for (int j = 0; j < eq_num; j++) {
        midvalues[j] = (*ODE[j])((j + 1) * 10) / 2;  // Value For Example
        printf("midvalues[%d]: %f\n", j, midvalues[j]);
    }
    return 0;
}

愛迪生

C的變體：

#include <stdio.h>

double voltage(double v) {
    return v;
}
double hdot(double h) {
    return h * 2;
}
double ndot(double n) {
    return n * 3;
}

typedef double(*eqpointer)(double);

int main() {
    eqpointer ODE[] = { voltage, hdot, ndot };
    int eq_num = sizeof(ODE)/sizeof(*ODE);

    // declared only for this examle
    double result;
    double k1 [eq_num], oneloop[eq_num], midvalues[eq_num];
    // or best malloc(eq_num * sizeof(double)); from stdlib

    for (int j = 0; j < eq_num; j++) {

        k1[j] = (*ODE[j])((j + 1) * 10);    // random arguments ODE for example only
        oneloop[j] =20 * (*ODE[j])(j + 1);
        midvalues[j] = (k1[j] + oneloop[j]) / 2;  
        result = (*ODE[j])(midvalues[j]);

        printf("*** %d) k1[]: %f, oneloop[]: %f, midvalues[]: %f result: %f\n",
            j, k1[j], oneloop[j], midvalues[j], result);
    }
    return 0;
}

#stdout 
*** 0) k1[]: 10.000000, oneloop[]: 20.000000, midvalues[]: 15.000000 result: 15.000000
*** 1) k1[]: 40.000000, oneloop[]: 80.000000, midvalues[]: 60.000000 result: 120.000000
*** 2) k1[]: 90.000000, oneloop[]: 180.000000, midvalues[]: 135.000000 result: 405.000000

愛迪生