通常情況下，需要調用由用戶提供的函數(shù)的算法是難以實現(xiàn)重用的。而實現(xiàn)重用的關鍵就在于尋找一種封裝用戶定義代碼的有效途徑。

引言
“代碼重用”是軟件工程追求的神圣目標之一。采用面向對象（object-oriented, OO）的程序設計方法的一個主要方面也就是為了代碼重用，這可以從任何介紹OO程序設計的書籍看得出來。然而實際應用中，使用C++一類的OO語言來實現(xiàn)代碼重用比我們想象的要難得多。事實上，正如一位作者所說，由于C++程序員普遍傾向于創(chuàng)建自己的容器類，“C++對科學計算軟件的可重用性造成了很大的阻礙”。
在本文中，我展示了怎樣用C++語言創(chuàng)建可重用的數(shù)學例程。相對于OO來說，我使用的方法更依賴于通用編程（Generic Programming）。為了討論的方便，我使用了一個廣泛應用的估計算法——Newton-Raphson算法來作為例子。Newton-Raphson算法必須調用一個用戶定義的函數(shù)。本文首先給出了用戶定義函數(shù)的典型（并不讓人滿意）封裝方法，然后提出了一種建立在模板和操作符重載基礎上的更加令人滿意的封裝方式。

Newton-Raphson算法
在科學計算和財經(jīng)工程領域，許多數(shù)值算法都是通用的（至少在理論上是），可廣泛地用于解決一類問題。一個大家熟悉的例子就是Newton-Raphson例程，它可用來尋找方程f(x)=0的數(shù)值解。標準的數(shù)學表達式f(x)表示f是變量x的函數(shù)，其通常的表達形式為f(x,a,b,...)=0，f被定義為多于一個變量的函數(shù)。在這種情況下，Newton-Raphson算法試圖把x以外的變量固定并作為參數(shù)，而尋找關于變量x的數(shù)值解。
由于Newton-Raphson算法需要知道被求解函數(shù)的確切表達，其傳統(tǒng)實現(xiàn)方法是直接將代碼嵌入到客戶應用程序中。這就使得算法的實現(xiàn)代碼經(jīng)過針對不同被求解函數(shù)的少量修改后在客戶程序中反復出現(xiàn)。
同許多其它數(shù)學例程一樣，Newton-Raphson算法的具體實現(xiàn)是應該與特定用戶無關的。并且，重復編碼在任何情況下都應該盡量避免。我們很自然地會想到把該類例程作為庫函數(shù)來實現(xiàn)，以使客戶程序可以直接調用它們。但是，這種實現(xiàn)方式必然會涉及到如何將用戶自定義函數(shù)（Newton-Raphson例程需要調用該函數(shù)）封裝成可以作為參數(shù)傳遞的形式。下面部分描述了一種通常的，也是存在很多問題的用戶定義函數(shù)封裝方法。

通常的實現(xiàn)途徑——函數(shù)指針

現(xiàn)在的任務就是把Newton-Raphson算法作為一個庫例程來實現(xiàn)，客戶程序可以直接調用該例程來對任何形如f(x,a,b,..)=0的方程求取關于x的數(shù)值解。問題的關鍵就是算法的實現(xiàn)必須使用（能夠調用）f(x,a,b,...）形式的通用函數(shù)，而該函數(shù)的具體定義由庫的用戶在以后提供，并且只能在運行時才提交給庫。對于C和C++程序員，一種自然的可能方式就是把函數(shù)指針作為參數(shù)傳遞給庫例程：

typedef double (*P2F)(double);

double NewtonRaphson(P2F func_of_x, double x_init,
) {
...
//通過函數(shù)指針調用函數(shù)
double y = func_of_x( x_init );
...
}

該庫例程工作得很好，但這僅僅是對于恰好只有一個參數(shù)的函數(shù)來說的。在C++中，程序員可以對庫函數(shù)進行重載，為具有不同參數(shù)數(shù)目的用戶定義函數(shù)分別定義一個例程。但是這樣會使得庫代碼出現(xiàn)大量的重復，并且更為糟糕的是，你不知道到底需要定義多少個這樣的庫例程。
另一種想法就是利用可選參數(shù)，如下面語句所示：

typedef double (*P2F)(double, ...);

這似乎看來可以結束這個問題的討論了。但是幸運也不幸運的是，C++不允許如上面代碼所期望的那樣使用可選參數(shù)。由于指向函數(shù)的指針必須準確地知道函數(shù)參數(shù)的類型和個數(shù)，該typedef定義的函數(shù)指針就只能與有一個double類型參數(shù)并跟上C風格的varargs的函數(shù)匹配，而不能用于包含了更多指定類型參數(shù)的函數(shù)。
當然還有其它的傳遞多參數(shù)函數(shù)的途徑，比如說可使用函數(shù)外殼。但是這種方法對于作者來說，除了求助于全局變量以外，并不清楚該怎樣去做。
為使其簡化，就需要使用一組包含了一定參數(shù)的構造，這些構造定義了復雜的用戶函數(shù)，并為庫例程通過傳遞單個參數(shù)來調用這個函數(shù)提供了途徑。這就將是一個對象——一個純粹并簡單的對象。因此，我為通用函數(shù)f(x,a,b,...)定義了一個類，并將其命名為FuncObj。（為了簡化敘述，從現(xiàn)在開始，參數(shù)的個數(shù)被固定為3個。）

class FuncObj {
private:
double _a;
int _b;
public:
FuncObj(double a_in, int b_in);

// 用x, a, b的形式定義用戶定義函數(shù)
double theFunc(double x_init);
};

你可能試圖通過向先前定義的庫例程傳遞一個指向FuncObj對象的theFunc成員函數(shù)的指針來調用該例程。但是這種方法不能工作，至少因為兩點原因。首先，在成員函數(shù)的表示中包含有類的名稱，指向它的指針不能用于需要一個指向普通函數(shù)的指針的地方。其次，指向成員函數(shù)的指針必須通過一個該類的對象實例來存取。我將在下一個部分解決這兩個問題。（需要注意的是，把theFunc定義成static類型無法真正解決問題，因為這樣的話，theFunc就不能存取FuncObj的非靜態(tài)成員變量，而正是這些成員變量保存了運算所需的其它“常值”變量。）

使用指向成員函數(shù)的指針

正如上一部分所討論到的，必須對庫接口進行修改，以便通過指向成員函數(shù)的指針來訪問。并且?guī)旖涌趹摱x成函數(shù)模板，使得它不局限于某一個特定的類。

template
double NewtonRaphson(T & func, double (T::*func_of_x)(double),
double x_init, ) {
...
// 通過對象（引用）和指向成員函數(shù)的指針
// 調用成員函數(shù)
double y = (func.*func_of_x)( x_init );
...
}

這段代碼能夠正常工作，但是其語法顯得有些難于理解。
為指向成員函數(shù)的指針創(chuàng)建類型定義是使代碼簡化并更可讀的一種有效途徑，就象先前為指向簡單函數(shù)的指針創(chuàng)建類型定義那樣。換句話說，創(chuàng)建帶參數(shù)化類型的類型定義會使程序顯得更加易懂，如下所示：

template
typedef double (T::*P2MF)(double);

如果上述代碼符合C++語法的話，P2MF的類型就是指向類T的成員函數(shù)的指針，該函數(shù)需要一個double型的參數(shù)，并返回一個double類型的值。然而遺憾的是，C++不支持包含了模板的類型定義。
按照計算機科學的慣例，最終的解決辦法就是引入另一級重定向。在該例中，可以通過定義一個封裝模板來使得上述類型定義變得合法：

template struct P2MFHelper {
typedef double (T::*P2MF)(double);
};

上面的代碼中演示了一種奇怪但是又很有趣的templete和typedef用法。現(xiàn)在，我可以重新定義庫函數(shù)如下：

template
double NewtonRaphson(T & func,
P2MFHelper::P2MF func_of_x,
double x_init, ) {
...
double y =
(func.*func_of_x)( x_init );
...
}

注意func.*func_of_x兩邊的括號對代碼的正確編譯和運行是必需的，因為接下來的函數(shù)調用比操作符.*具有更高的優(yōu)先級。同時Helper類和庫函數(shù)也可以合并到一個單一的模板類中，并且能夠達到同樣的目的。然而，把Newton-Raphson例程設計成一個類并不是一種好的方式。不用說，這將會導致語法變得稍微有一些復雜。
現(xiàn)在，該庫例程可以適用于具有不同參數(shù)數(shù)目的用戶定義函數(shù)，只要客戶程序員定義一個FuncObj風格的類來封裝每一種該類型的函數(shù)。但是，這種方法還具有兩個小的問題。首先，你無法再向Newton-Raphson歷程傳遞指向普通函數(shù)的指針。其次，同時傳遞一個對象和一個指向成員函數(shù)的指針將使程序變得不健壯和不經(jīng)濟。下面我來討論如何克服這兩個缺點。

使用函數(shù)對象
函數(shù)對象是一個重載了函數(shù)調用操作符()的類。因此，就能夠使用函數(shù)對象重載了的操作符()來代替函數(shù)調用操作符。下面是我重新定義的FuncObj:

class FuncObj {
public:
// 操作符重載
double operator() (double x_init) {
// 操作符重載實現(xiàn)代碼
// 實現(xiàn)以x, a, b形式定義的用戶定義函數(shù)
}
};

現(xiàn)在，庫例程可以直接使用函數(shù)對象進行簡單的定義：

template
double NewtonRaphson(T & func,
double x_init,
) {
...
// 調用函數(shù)對象實例的成員函數(shù)或()運算符
double y = func( x_init );
...
}

從上面的代碼可以看出，只向NewtonRaphson庫例程傳遞了一個參數(shù)化了的變量。該類型可以用一個對象引用或者指向普通函數(shù)的指針來代替。并且，庫例程內部的“函數(shù)調用”變得更加簡單了。作為一個例子，下面看一看如何用該通用庫例程來求解一個無解析解的復雜方程x3 + 2ex + 7 = 0。函數(shù)對象定義如下：

class FuncObj {
private:
double _a;
double _b;

public:
FuncObj(double a_in, double b_in) :
_a(a_in), _b(b_in) {};

// 重載操作符
double operator() (double x_in) {
return ( x_in*x_in*x_in +
_a*exp(x_in) + _b );
}

double solve(double x_in) {
// 調用通用庫例程
return NewtonRaphson(*this, x_in,
other_arguments);
}
};

在主程序中，只需要簡單地調用庫例程：

void main() {
FuncObj fo(2.0, 7.0);

// 間接調用Newton-Raphson庫例程
double solution_1 = fo.solve(-4.0);

// 直接調用庫例程
double solution_2 =
NewtonRaphson(fo, -4.0,
other_arguments);
}

注意該版本的庫函數(shù)同時被用在函數(shù)對象的內部和外部。main函數(shù)演示了通過傳遞一個對象引用來直接調用該庫例程的方法。但是，通過向該庫函數(shù)傳遞一個合適的指向函數(shù)的指針來調用它也是可行的。

結論
通過充分利用C++兩個強大的機制，我完成了一種可重用的Newton-Raphson算法的庫實現(xiàn)。該庫是通用的，可廣泛用于解決一些類似的問題，并且對客戶程序的要求只是為該庫函數(shù)要調用的用戶定義函數(shù)（對象）重載()操作符即可。
本文討論的方法可應用到許多常見的可用來解決一類數(shù)學問題的科學算法。比如說，對任意復雜函數(shù)的數(shù)值積分，就可以用相同的方法來處理。C++語言的兩個關鍵特性——命名函數(shù)模板和操作符重載，使得這種簡單、健壯的解決途徑變得可行。把函數(shù)定義成對象所造成的開銷其實是可以忽略不計的。事實上，現(xiàn)實應用中的許多復雜函數(shù)都已經(jīng)被定義成了對象，當它們需要被Newton-Raphson算法一類的通用數(shù)學例程調用時，只要簡單地在類中重載()操作符即可。因此，用一個可重用的本地庫來實現(xiàn)一整套數(shù)學算法是可行的。

總結

以上是生活随笔為你收集整理的用C++实现可重用的数学例程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內容還不錯，歡迎將生活随笔推薦給好友。