函数

void swap(int *p1, int *p2) 
{ 
  int tmp = *p2;
  *p2 = *p1;
  *p1 = tmp;
}

void swap(int &v1, int &v2) 
{ 
  int tmp = v2; 
  v2 = v1; 
  v1 = tmp; 
}

swap(i, j);

Before swap(): i: 10 j: 20 
After  swap(): i: 20 j: 10

// compare the length of two strings 
bool isShorter(const string &s1, const string &s2) 
{ 
  return s1.size() < s2.size(); 
}

// swap values of two pointers to int 
void ptrswap(int *&v1, int *&v2) 
{ 
  int *tmp = v2; 
  v2 = v1; 
  v1 = tmp; 
}

int *&v1

int main() 
{ 
  int i = 10; 
  int j = 20; 
  int *pi = &i;  // pi points to i 
  int *pj = &j; // pj points to j 
  cout << "Before ptrswap():\t*pi: " 
       << *pi << "\t*pj: " << *pj << endl; 
  ptrswap(pi, pj); // now pi points to j; pj points to i 
  cout << "After ptrswap():\t*pi: "
       << *pi << "\t*pj: " << *pj << endl; 
  return 0; 
}

Before ptrswap(): *pi: 10 *pj: 20 
After ptrswap():  *pi: 20 *pj: 10

// 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]) { /* ... */ }

// f won't change the elements in the array 
void f(const int*) { /* ... */ }

// 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 ints 
  return 0; 
}

// ok: parameter is a reference to an array; size of array is fixed 
void printValues(int (&arr)[10]) 
{ 
  for (size_t i = 0; i != 10; ++i) { 
    cout << arr[i] << endl; 
  } 
}

f(int &arr[10])     // error: arr is an array of references 
f(int (&arr)[10]) // ok: arr is a reference to an array of 10 ints

void printValues(const int *beg, const int *end) 
{ 
  while (beg != end) { 
    cout << *beg++ << endl; 
  } 
} 
int main() 
{ 
  int j[2] = {0, 1}; 
  // ok: j is converted to pointer to 0th element in j 
  //     j + 2 refers one past the end of j 
  printValues(j, j + 2); 
  return 0; 
}

// const int ia[] is equivalent to const int* ia 
// size is passed explicitly and used to control access to elements 
of ia 
void printValues(const int ia[], size_t size) 
{ 
  for (size_t i = 0; i != size; ++i) { 
    cout << ia[i] << endl; 
  } 
} 
int main() 
{ 
  int j[] = { 0, 1 }; // int array of size 2 
  printValues(j, sizeof(j)/sizeof(*j)); 
  return 0; 
}

// return plural version of word if ctr isn't 1 
string make_plural(size_t ctr, const string &word, 
                   const string &ending) 
{ 
  return (ctr == 1) ? word : word + ending; 
}

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

// Disaster: Function returns a reference to a local object 
const string &manip(const string& s) 
{ 
     string ret = s; 
     // transform ret in some way 
     return ret; // Wrong: Returning reference to a local object! 
}

char &get_val(string &str, string::size_type ix) 
{ 
  return str[ix]; 
} 
int main() 
{ 
  string s("a value"); 
  cout << s << endl;   // prints a value 
  get_val(s, 0) = 'A'; // changes s[0] to A 
  cout << s << endl;   // prints A value 
  return 0; 
}

const char &get_val(...

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,' ')

string::size_type screenHeight(); 
string::size_type screenWidth(string::size_type); 
char screenDefault(char = ' '); 
string screenInit( 
                  string::size_type height = screenHeight(), 
                  string::size_type width = screenWidth(screenHeight()), 
                  char background = screenDefault());

// ff.h 
int ff(int = 0); 
// ff.cc 
#include "ff.h" 
int ff(int i = 0) { /* ... */ } // error

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

cout << shorterString(s1, s2) << endl;

cout << (s1.size() < s2.size() ? s1 : s2) << endl;

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

Record lookup(const Account&);  // find by Account 
Record lookup(const Phone&);    // find by Phone 
Record lookup(const Name&);     // find by Name 
Record r1, r2; 
r1 = lookup(acct);                  // call version that takes an Account 
r2 = lookup(phone);                 // call version that takes a Phone

/* Program for illustration purposes only: 
 * It is bad style for a function to define a local variable 
 * with the same name as a global name it wants to use 
 */ 
string init(); // the name init has global scope 
void fcn() 
{ 
  int init = 0;        // init is local and hides global init 
  string s = init();   // error: global init is hidden 
}