C++primer第七章 函数

            bool is_present(int *, int); // returns boolint count(conststring &, char); // returns int
Date &calendar(constchar*); // returns reference to Datevoid process(); // process does not return a value

            //
             error: missing return type
test(double v1, double v2) { /* ... */ }

            int manip(int v1, v2) { /* ... */ } // errorint manip(int v1, int v2) { /* ... */ } // ok

            //
             incorrect version of swap: The arguments are not changed!
            void swap(int v1, int v2)
{
    int tmp = v2;
    v2 = v1; // assigns new value to local copy of the argument
    v1 = tmp;
} // local objects v1 and v2 no longer exist

            //
             ok: swap acts on references to its arguments
            void swap(int &v1, int &v2)
{
    int tmp = v2;
    v2 = v1;
    v1 = tmp;
}

            //
             returns an iterator that refers to the first occurrence of value

            //
             the reference parameter occurs contains a second return value
vector<int>::const_iterator find_val(
    vector<int>::const_iterator beg, // first element
    vector<int>::const_iterator end, // one past last elementint value, // the value we want
    vector<int>::size_type &occurs) // number of times it occurs{
    // res_iter will hold first occurrence, if any
    vector<int>::const_iterator res_iter = end;
    occurs = 0; // set occurrence count parameterfor ( ; beg != end; ++beg)
        if (*beg == value) {
        // remember first occurrence of valueif (res_iter == end)
                res_iter = beg;
            ++occurs; // increment occurrence count        }
    return res_iter; // count returned implicitly in occurs
}

            //
             function takes a non-const reference parameter
            int incr(int &val)
{
    return ++val;
}
int main()
{
    short v1 = 0;
    constint v2 = 42;
    int v3 = incr(v1); // error: v1 is not an int
    v3 = incr(v2); // error: v2 is const
    v3 = incr(0); // error: literals are not lvalues
    v3 = incr(v1 + v2); // error: addition doesn‘t yield an lvalueint v4 = incr(v3); // ok: v3 is a non const object type int
}

            //
             pass iterators to the first and one past the last element to print
            void print(vector<int>::const_iterator beg, vector<int>::const_iterator end)
{
    while (beg != end) {
        cout << *beg++;
        if (beg != end) cout << ""; // no space after last element    }
    cout << endl;
}

            //
             three equivalent definitions of printValues
            void printValues(int*) { /* ... */ }
void printValues(int[]) { /* ... */ }
void printValues(int[10]) { /* ... */ }

            //
             parameter treated as const int*, size of array is ignored
            void printValues(constint ia[10])
{
// this code assumes array has 10 elements;
// disaster if argument has fewer than 10 elements!for (size_t i = 0; i != 10; ++i)
{
cout << ia[i] << endl;
}
}

            int
             main()
{

            int i = 0, j[2] = {0, 1};
printValues(&i); // ok: &i is int*; probable run-timeerror
printValues(j); // ok: j is converted to pointer to 0th
// element; argument has type int*;
// probable run-time errorreturn0;
}

            //
             ok: parameter is a reference to an array; size of array is fixed
            void printValues(int (&arr)[10]) { /* ... */ }
int main()
{
    int i = 0, j[2] = {0, 1};
    int k[10] = {0,1,2,3,4,5,6,7,8,9};
    printValues(&i); // error: argument is not an array of 10 ints
    printValues(j); // error: argument is not an array of 10 ints
    printValues(k); // ok: argument is an array of 10 intsreturn0;
}

            //
             calculate val!, which is 1*2 *3 ... * val
            int factorial(int val)
{
    if (val > 1)
        return factorial(val-1) * val;
    return1;
}    

            string screenInit(string::size_type height = 24,
    string::size_type width = 80,
    char background = ‘‘ );

            string
             screen;
screen = screenInit(); // equivalent to screenInit (24,80,‘‘)
screen = screenInit(66); // equivalent to screenInit (66,80,‘‘)
screen = screenInit(66, 256); // screenInit(66,256,‘ ‘)
screen = screenInit(66, 256, ‘#‘);

screen = screenInit(, , ‘?‘); // error, can omit only trailing arguments
screen = screenInit( ‘?‘); // calls screenInit(‘?‘,80,‘ ‘)

            //
             inline version: find longer of two strings
inline conststring &
shorterString(conststring &s1, conststring &s2)
{
    return s1.size() < s2.size() ? s1 : s2;
}

            double Sales_item::avg_price() const
{
    if (units_sold)
        return revenue/units_sold;
    elsereturn0;
}    

            //
             pf points to function returning bool that takes two const stringreferences
            bool (*pf)(conststring &, conststring &);

typedef bool (*cmpFcn)(conststring &, conststring &);