平凡的世界

[C/C++] - Tips for STL and Generic Programming

關于STL與“泛型”編程的忠告（v1.5）

Translated By Phoenix(E-Mail:phoenix8848@gmail.com)

       Tip 15: The Location of Template Definitions

       忠告15：模板定義的位置

       Normally, you declare functions and classes in a .h file and place their definition in a separate .cpp file. With templates, this practice isn't really useful because the compiler must see the actual definition (i.e., the body) of a template, not just its declaration, when it instantiates a template. Therefore, it's best to place both the template's declaration and definition in the same .h file. This is why all STL header files contain template definitions. 
       通常你在.h文件中聲明函數與類而把它們的實現(xiàn)放在若干個.cpp文件中（以使聲明與實現(xiàn)分開）。使用模板的時候這樣的做法作用不大因為編譯器在實例化一個類模板時必須顯式地獲得類模板的實際定義（例如函數體），而不僅僅是它的聲明。所以最好是把類模板的聲明和實現(xiàn)放在同一個頭文件中。這就是為什么所有的STL（標準模板庫，即Standard Template Library，是一個C++軟件庫，也是C++標準程式庫的一部分）頭文件都包含模板的實現(xiàn)。
       In the future, when compilers support the "export" keyword, it will be possible to use only the template's declaration and leave the definition in a separate source file.

       將來當編譯器支持“export”命令時，有可能只需要模板的聲明而將它的實現(xiàn)放在單獨的源文件中。

       Tip 16: Standard Base Classes for Function Object

       忠告16：函數對象的標準基類

       To simplify the process of writing function objects, the Standard Library provides two class templates that serve as base classes of user-defined function objects: std::unary_function and std::binary_function. Both are declared in the header “functional”. As the names suggest, unary_function serves as a base class of function objects taking one argument and binary_function serves as a base class of function objects taking two arguments. The definitions of these base classes are as follows:

       為了簡便地處理寫入函數對象，標準庫提供了兩個類模板以作為用戶自定義函數對象的基類：std::unary_function和std::binary_funcation。這兩個模板都聲明在頭文件“functional”中。正如模板名字所示，unary_funcation作為單參數函數對象的基類而binary_function作為雙參數函數對象的基類。這兩個基類的定義如下所示：

 1template <class Arg, class Res> 
 2struct unary_function 
 3{
 4    typedef Arg argument_type;
 5    typedef Res result_type;
 6};
 7
 8template <class Arg, class Arg2, class Res> 
 9struct binary_function 
10{
11    typedef Arg first_argument_type;
12    typedef Arg2 second_argument_type;
13    typedef Res result_type;
14};
15
16

       These templates don't provide any useful functionality. They merely ensure that arguments and return values of their derived function objects have uniform names. In the following example, the predicate is_vowel, which takes one argument, inherits from unary_function:

       這兩個模板并沒有提供任何有用的功能。它們僅僅是為了保證派生出來的函數對象的參數與返回值具有不同的名字。在下面的例子中聲明了從unary_function派生的_vowel，它只有一個參數。

 1template <class T> 
 2class is_vowel: public unary_function<T, bool>
 3{
 4public:
 5    bool operator ()(T t) const
 6    {
 7        if ((t=='a')||(t=='e')||(t=='i')||(t=='o')||(t=='u'))
 8            return true;
 9        else
10            return false;
11    }
12};

       Tip 17: Storing Dynamically Allocated Objects in STL Containers

       忠告17：在標準模板庫容器中保存動態(tài)生成的對象

       Suppose you need to store objects of different types in the same container. Usually, you do this by storing pointers to dynamically allocated objects. However, instead of using named pointers, insert the elements to the container as follows:

       假設你需要在一個容器中存儲不同的對象。通常你會通過保存動態(tài)生成對象的指針來實現(xiàn)。無論如何不要用命名的指針，而是像下面所示的這樣添加元素到容器中：

1class Base {};
2class Derived : public Base{};
3
4std::vector<Base *> v;
5v.push_back(new Derived);
6v.push_back(new Base);

       This way you ensure that the stored objects can only be accessed through their container. Remember to delete the allocated objects as follows:

       這樣你可以保證存儲的對象只能通過容器訪問到。切記要用下面所示的方法釋放對象：

1delete v[0];
2delete v[1];
3

       Tip 18: Treating a Vector as an Array

       忠告18：將向量容器看作是數組

       Suppose you have a vector of int and function that takes int *. To obtain the address of the internal array of the vector v and pass it to the function, use the expressions &v[0] or &*v.front(). For example:

       假設你有一個保存整型變量的向量容器和一個處理整型指針int*的函數。為了獲得向量容器v中的內部數組并把它傳遞給函數，應該使用表達式&v[0]或者&*v.front()，如示例：

 1void func(const int arr[], size_t length );
 2
 3int main()
 4{
 5    vector<int> vi;
 6    //.. fill vi
 7    func(&vi[0], vi.size());
 8}
 9
10

       It's safe to use &vi[0] and &*v.front() as the internal array's address as long as you adhere to the following rules: First, func() shouldn't access out-of-range array elements. Second, the elements inside the vector must be contiguous. Although the C++ Standard doesn't guarantee that yet, I'm not aware of any implementation that doesn't use contiguous memory for vectors. Furthermore, this loophole in the C++ Standard will be fixed soon.

       如果你能遵循下面的規(guī)則使用&vi[0]和&*v.front()作為內部數組的地址是安全的：第一，func()函數不能試圖訪問超出范圍的數組元素。第二，向量容器內的元素必須是連續(xù)的。盡管C++標準并不要求如此，但我不知道有別的為容器實現(xiàn)不使用連續(xù)內存。而且，C++標準不久就會修補這個漏洞。

       Tip 19: Dynamic Multidimensional Arrays and Vectors

       忠告19：動態(tài)多維數組與容器

       You can allocate multidimensional arrays manually, as in:

       通常你會像下面的方式來分配多維數據：

 1int (*ppi) [5]=new int[4][5]; /**//*parentheses required*/
 2
 3/**//*fill array..*/
 4
 5ppi[0][0] = 65;
 6ppi[0][1] = 66;
 7ppi[0][2] = 67;
 8
 9//..
10
11delete [] ppi;

       However, this style is tedious and error prone. You must parenthesize ppi to ensure that the compiler parses the declaration correctly, and you must delete the allocated memory. Worse yet, you can easily bump into buffer overflows. Using a vector of vectors to simulate a multidimensional array is a significantly superior alternative:

       可是這種做法是冗長而且非常容易出錯。你必須把ppi放入括號內以便編譯器可以正確地分析這些聲明，并且（最后）你必須（顯式地）地釋放這些分配的內存空間。更糟糕的是，你會很容易地造成緩沖溢出。使用“容器之容器”來模擬多維數組是一種高明得多的選擇。

 1#include <vector>
 2#include <iostream>
 3using namespace std;
 4
 5int main()
 6{
 7    vector<vector<int>> v; /**//*two dimensions*/
 8    v.push_back(vector<int>()); /**//*create v[0]*/
 9    v.push_back(vector<int>()); /**//*create v[1]*/
10    v[0].push_back(15); /**//*assign v[0][0]*/
11    v[1].push_back(16); /**//*assign v[1][0]*/
12}

       Because vector overloads operator [], you can use the [][] notation as if you were using a built-in two-dimensional array:

       因為容器重載了操作符[]，所以你可以用[][]來操作就如同使用內置的二維數組。

1cout<<v[0][0]; 
2cout<<v[1][0];

       The main advantages of using a vector of vectors are two: vector automatically allocates memory as needed. Secondly, it takes care of deallocating memory so you don't have to worry about potential memory leaks.

       使用“容器之容器”有兩個主要的好處：第一，容器會在需要時自動分配內存。第二，容器可以自動回收內存所以你不必操心潛在的內存泄漏。

       Tip 20: Why You Shouldn't Store auto_ptr Objects in STL Containers

       忠告20：為什么不能在標準模板庫容器中存儲auto_ptr

       The C++ Standard says that an STL element must be "copy-constructible" and "assignable." These fancy terms basically mean that for a given class, assigning and copying one object to another are well-behaved operations. In particular, the state of the original object isn't changed when you copy it to the target object.

       C++標準中說一個STL元素必須是可復制構造(copy-constructible)和可賦值(assignable)的。這些充滿科幻色彩的詞匯的基本意思是對于一個給定的類，對象間的賦值與復制是一種表現(xiàn)良好的操作。特別的，源對象被復制給一個目標對象時源對象不會有任何改變。

       This is not the case with auto_ptr, though: copying or assigning one auto_ptr to another makes changes to the original in addition to the expected changes in the copy. To be more specific, the original object transfers ownership of the pointer to the target, thus making the pointer in the original null. Imagine what would happen if you did something like this:

       這不適用于auto_ptr。因為，把一個auto_ptr對象復制或賦值給另一個對象會引起原始對象的改變從而引起對象副本的改變。更細節(jié)地看，原始對象把指針的權限傳遞給了目標對象，這使源對象中的指針變成空指針。設想當你進行下面這樣操作的時候會發(fā)生什么：

 1std::vector<auto_ptr<Foo>> vf;/**//*a vector of auto_ptr's*/
 2
 3// ..fill vf
 4
 5int g()
 6{
 7    std::auto_ptr<Foo> temp=vf[0]; /**//*vf[0] becomes null*/
 8}
 9
10

       When temp is initialized, the pointer of vf[0] becomes null. Any attempt to use that element will cause a runtime crash. This situation is likely to occur whenever you copy an element from the container. Remember that even if your code doesn't perform any explicit copy or assignment operations, many algorithms (std::swap(), std::random_shuffle() etc.) create a temporary copy of one or more container elements. Furthermore, certain member functions of the container create a temporary copy of one or more elements, thereby nullifying them. Any subsequent attempt to the container elements is therefore undefined.

       當臨時對象被初始化，vf[0]的指針變?yōu)榭?。任何試圖使用這個元素都會引起運行時崩潰。無論什么時候你從容器復制這個元素都會引發(fā)這種意外。切記即使你的代碼不進行任何顯示的復制與賦值操作，很多算法（如std::swap(), std::random_shuffle()）都會（隱蔽地）創(chuàng)建一個或更多容器元素的臨時副本。此外，容器的某些特定成員函數也會一個或列多元素的臨時副本，從而使這些元素失效。任何隨后的對容器元素的操作意圖都由此變?yōu)椴豢深A期的。

       Visual C++ users often say that they have never encountered any problems with using auto_ptr in STL containers. This is because the auto_ptr implementation of Visual C++ (all versions thereof) is outdated and relies on an obsolete specification. When the vendor decides to catch up with the current ANSI/ISO C++ Standard and change its Standard Library accordingly, code that uses auto_ptr in STL containers will manifest serious malfunctions.

       Visual C++用戶經常說他們在標準模板容器中使用auto_ptr時從沒遇到什么問題。這是因為Visual C++中auto_ptr的實現(xiàn)（目前為止所有的版本）都是過時的和參考了舊的規(guī)范說明。當微軟決定采用現(xiàn)在的ANSI/ISO C++標準并據此對它的標準庫進行更新時，以前在標準模板容器中使用auto_ptr的代碼就會突現(xiàn)嚴重的問題。

       To conclude, you shouldn't use auto_ptr in STL containers. Use either bare pointers or other smart pointer classes instead of auto_ptr (such classes are available at www.Boost.org).

       作為結論，你最好不要在標準容器中使用auto_ptr，而是使用原始指針或別的智能指針類來代替auto_ptr（比如BOOST庫）