// 不良设计：第一个形参的类型应该是const string&
　　　　string::size_type find_char(string &s, char c,
                                             string::size_type &occurs);
　　　　// 只能将find_char函数作用于string对象。

　　　　find_char("Hello World", ‘o‘, ctr);    // 错误
　　　　// 尽量使用常量引用

　　　　// 正确：形参是数组的应用，维度是类型的一部分
　　　　void print(int (&arr)[10])   // &arr两端的括号必不可少
　　　　{
   　　　　 for (auto elem : arr)
       　　　　 cout << elem << endl;
　　　　}

　　　　// matrix 指向数组的首元素，该数组的元素是由10个整数构成的数组
　　　　void print(int (*matrix)[10], int rowSize)      { /*  ...  */}
　　　　//  再次强调， *matrix两端的括号必不可少
　　　　//  int *matrix[10];        10个指针构成的数组
　　　　//  int (*matrix)[10];      指向含有10个整数的数组的指针

　　　　// 等价定义
　　　　void print(int matrix[][10], int rowSize) { /*  ...  */}
　　　　// matrix 的声明看起来是一个二维数组，实际上形参是指向含有10个整数的数组的指针

　　　　int main(int argc, char *argv[])
　　　　// 第二个形参argv是一个一维数组，它的元素是指向C风格字符串的指针

　　　　// 等价定义
　　　　int main(int argc, char **argv)    { ... }

　　　　// 严重错误：这个函数试图返回局部对象的引用
　　　　const string &manip()
　　　　{
  　　　　  string ret;
 　　　　   //  以某种方式改变一下ret
 　　　　   if (!ret.empty())
   　　　　     return ret;            //  错误：返回局部对象的引用
　　　　    else
     　　　　   return "Empty";   //  错误："Empty"是一个局部临时量
　　　　}
　　　　// 上面的两条return语句都将返回未定义的值，也就是，试图使用manip函数的返回值将
　　　　//  发生未定义的行为。对于第一条return语句来说，显然它返回的是局部对象的引用。在
　　　　// 第二条return语句中，字符串字面值转换成一个局部临时string对象，对于manip来说
　　　　// 该对象和ret一样都是局部的。当函数结束时临时对象占用的空间也就随之释放掉了，所
　　　　// 以两条return语句都指向了不再可用的内存空间。

　　　　// 我们能为返回类型是非常量引用的函数
　　　　char &get_val(string &str, string::size_type ix)
　　　　{
 　　　　   return str[ix];
　　　　}

　　　　int main()
　　　　{
  　　　　  string s("a value");
　　　　    cout << s << endl;           // 输出a value
　　　　    get_val(s, 0) = ‘A‘;            // 将s[0]的值改为A
　　　　    cout << s << endl;
　　　　    return 0;
　　　　}
　　　　// 如果返回类型是常量引用，我们不能给调用的结果赋值

　　　　vector<string> process()
　　　　{
   　　　　 // ...
  　　　　  // expected 和 actual是string对象
  　　　　  if (expected.empty())
  　　　　      return {};
 　　　　   else if (expected == actual)
 　　  　　     return { "functionX", "okay"};
  　　　　  else
        return { "functionX", expected, actual };
　　　　}
　　　　// 如果函数返回的是类类型，由类本身定义初始化值如何定义

　　　　// func接受一个int类型的实参，返回一个指针，该指针指向含有10个整数的数组
　　　　auto func(int i) -> int (*)[10];

　　　　int odd[] = {1, 3, 5, 7, 9};
　　　　int even[] = {0, 2, 4, 6, 8};
　　　　// 返回一个指针，该指针指向含有5个整数的数组
　　　　decltype(odd) *arrPtr(int i)
　　　　{
  　　　　  return (i % 2) ? &odd : &even;
　　　　}

　　　　Record lookup(Phone);
　　　　Record lookup(const Phone);       //  重复声明了Record lookup(Phone)

　　　　Record lookup(Phone*);
　　　　Record lookup(Phone* const);     // 重复声明了Record lookup(Phone*)

　　　　// 对于接受引用或指针的函数来说，对象是常量还是非常量对应的形参不同
　　　　// 定义了4个独立的重载函数
　　　　Record lookup(Account&);            // 函数作用于Account的引用
　　　　Record lookup(const Account&);   // 新函数，作用于常量引用

　　　　Record lookup(Account*);          // 新函数，作用于指向Account的指针
　　　　Record lookup(const Account*); // 新函数，作用于指向常量的指针

　　　　// 比较两个string对象的长度，返回较短的那个引用
　　　　const string &shorterString(const string &s1, const string &s2)
　　　　{
   　　　　 return s1.size() <= s2.size() ? s1 : s2;
　　　　}
　　　　// 上面的返回结果仍然是const stirng的引用，因此我们需要一种新的shorterString函数
　　　　// ，当它的实参不是常量时，得到的结果是一个普通的引用，使用const_cast可以做到这一点
　　　　string &shorterString(string &s1, string &s2)
　　　　{
 　　　　   auto &r = shorterString(const_cast<const string&>(s1),
 　　　　                                           const_cast<const string&>(s2));
　　　　    return const_cast<string&>(r);
　　　　}
　　　　// 这个引用事实上绑定在了某个初始的非常量的实参上，所以，我们可以再将其转换回一个
　　　　// 普通的stirng&，这显然是安全的

　　　　　　　　const int new_sz()  { return 42; }
　　　　　　　　const int foo = new_sz();    // 正确:foo是一个常量表达式