C++: newton raphson и функции за претоварване

Мисля, че питате за различни функции:

Променлива функция – функция, декларирана със списък с параметри, завършващ с многоточие (...) – може да приема различен брой аргументи от различни типове. Различните функции са гъвкави, но са и опасни. Компилаторът не може да провери дали дадено извикване на variadic функция предава подходящ брой аргументи или че тези аргументи имат подходящи типове. Следователно, извикване по време на изпълнение на variadic функция, която предава неподходящи аргументи, води до недефинирано поведение. Такова недефинирано поведение може да се използва за изпълнение на произволен код. Оттук:

https://www.securecoding.cert.org/confluence/display/cplusplus/DCL31-CPP.+Do+not+define+variadic+functions

Въпреки това, както е цитирано по-горе, има редица проблеми с тях.

Най-вече работи само за време за компилиране!

Ако обаче се интересувате от прилагането на такъв, ето статия с хубав пример:

http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=138

АКТУАЛИЗАЦИЯ:

IMO, мисля, че е по-добре да дефинирате функции, които приемат структурни или обектни аргументи (т.е. общ функционален обект), и да пишете функции, които работят с тези аргументи изрично.

Другата опция е да направите малко отражение по време на компилиране - което би било полезно, но е твърде много трудности за правене в такъв пример като този. Освен това „отражението“ в C++ не е „истинско“ отражение, а по-скоро лошо и непълно негово изпълнение.

За това, което се опитвате да направите тук, това, което търсите, е std::bind (или, ако имате работа с C++03 компилатор, std::bind1st и std::bnd2nd).

Те ще ви позволят да "свържете" стойности с другите параметри, оставяйки ви с функция (технически функционален обект), която изисква само един параметър.

Това, което бихте искали в идеалния случай, би било нещо подобно:

double f(double x, double y) { 
     return 3*x + 2*y;
}

double init = 1.0;

newton_raphson(init, std::bind2nd(f, 3), 1e-4);

За съжаление, в реална употреба не е толкова просто -- за да работите с std::bind2nd, не можете да използвате действителна функция; вместо това трябва да използвате функционален обект и той трябва да произлиза от std::binary_function.

std::bind е доста по-гъвкав, така че почти със сигурност искате да използвате вместо него (ако изобщо е възможно).

Използвах вашия въпрос като начин да се принудя да науча променлив шаблон на C++11, ето един работещ пример.

template< typename... Ts >
double f( Ts... Vs ) {
    double array[] = { Vs... };
    int numArg = sizeof...( Vs );
    switch (numArg) {
    case 1:
        return 3 * array[0] + 2;
    case 2:
        return 3 * array[0] + 2 * array[1];
    case 3:
        return 3 * array[0] + 2 * array[1] + 1 * array[3];
    ....
    default:
        return 0.0;
    }
}

template< typename... Ts >
double newton_raphson( double &init, double tol,
                       double (*func) ( Ts... Vs ), Ts... Vs ) {
    return func( Vs... );
}

можете да го наречете така

newton_raphson( &init, 1.0, f, 1.0, 2.0, 3.0, 4.0, 5.0 );

Можете да използвате std::bind и std::function. Типът std::function<double(double)> представлява функционалност, която приема двойно и връща двойно. По подобен начин std::function<double(int,int)> е за функционал, който взема 2 int и връща двойно.

#include <functional>

bool newton_raphson(double& init,
                    std::function<double(double)>& f,
                    double tol){
    const int max_iter = 10000;
    double next_x, soln = init;
    int i = 0;

    while(++i < max_iter){
        next_x = soln - f(soln)/fp_x(f, soln);
        if(fabs(next_x - soln) < tol){
            init = next_x;
            return true;
        }
        soln = next_x;
    }
    return false;
}

double myfunction(double x, double y){
    return (3*x + 2*y);
}
double fp_x(std::function<double(double)> f, double x) {
    ...
}
...
double d = 1.0;
// Here we set y=2.5 and we tell bind that 1st parameter is unbounded
// If we wanted to switch and set x=2.5 and let y be unbounded, then
// we would use  (&myfunction, 2.5, std::placeholders::_1)
newton_raphson(d, std::bind(&myfunction, std::placeholders::_1, 2.5) , 1e-6);
...