C++ primer 第五版个人笔记第六章函数

朱雀 2023-05-21 07:29 16阅读 0赞

### 6.1 函数基础 ###

1.  通过调用运算符（call operator）来执行函数。调用运算符的形式是一怼圆括号（），它作用于一个表达式，该表达式是函数或者指向函数的指针；调用表达式的类型就是函数的返回类型。 int function() 是一个调用表达式，是用调用运算符（）作用于函数名function(实际上是指针），int类型为调用表达式的类型，也是函数的返回类型；
2.  函数的三要素（返回类型，函数名，形参类型） 描述了函数的接口，说明了调用该函数所需的全部信息。函数声明也称作函数原型；

### 6.2 参数传递 ###

1.  使用引用来避免拷贝，当拷贝打的类类型对象或者容器对象时，由于拷贝比较低效甚至有的对象不支持拷贝构造，这是使用引用形参是比较明智的选择；
2.  当函数无需改变引用形参的值时，最好将其声明为常量引用；
3.  当用实参初始化形参是会忽略掉顶层const（形参的顶层const被忽略了），当形参有顶层const时，传给他常量或者非常量对象都是可以的；
    
        //下面两句语句是等效的，因此不能视作函数重载
        void fun(const int i) {} ;
        void fun(int i) {};
    
     
4.  练习6.17
    
        bool hasUpper(const string&str)
        {
        	for (auto ch : str)
        	{
        		if (isupper(ch)) return true;
        	}
        	return false;
        }
        
        void strtolower(string& str)
        {
        	for (auto &ch : str)
        	{
        		ch = tolower(ch);
        	}
        	return;
        }
    
     
    
     
5.  数组的两个特殊性质：不允许拷贝数组，使用时将转化为指针；导致无法以之传递的形式使用数组参数，但是可以把形参写成类似数组的形式，以下三种声明方式等效：
    
        void print(const *int);
        void print(const int[]);    //可以看出函数的意图是作用一个数组
        void print(const int[10]);  //这里的维度表示期望数组有多少个元素，无论写多少都是将第一个元素的指针传入
    
     
    
     
6.  3种办法管理指针型形参使其不越界：
    
        // 1. 使用标记指定数组长度，这里C风格字符串结尾标记是'\0'
        
        void print(const char *p)
        {
            if(cp)
                while(*p) cout<<*cp++;
        }
        
        // 2. 使用标准库规范， begin(), end()函数可以返回容器内容的第一个元素的指针迭代器和最后一个元素下一位的指针迭代器
        
        void print(const int *beg, const int *end)
        {
            while(beg!=end) cout<<*beg++<<endl;
        }
        print(begin(j),end(j));
        
        
        // 3. 显式传递一个表示数组大小的形参
        
        void print(consti int ia[], size_t size)
        {
            for(size_t i=0;i<size;++i)
            {
                cout<<ia[i]<<endl;
            }
        }
    
     
7.  传递多维数组的两种形参方式：
    
        void print(int (*matrix)[10],int rowsize);
        void print(int matrix[][10], int rowsize);
    
     
8.  main函数的两个参数 int main(int argc, char\*argv\[\])， 第一个argc表示命令行输入的行数，第二个argv表示指向C字符串风格的指针（即指向指针的指针，类型可以表示为 char\*\*），第一行是指向程序的名字或者空字符串，下面的元素依次传递命令行提供的实参，最后一个指针之后的元素值保证为0；例子如下：
    
        prog -d -o ofile data0 // 命令行的参数
        int main(int argc, char **argv) 
        //上面命令等同于如下过程, prog为可执行程序
            argv[0] = "prog";        
            argv[1] = "-d";
            argv[2] = "-o";
            argv[3] = "ofile";
            argv[4] = "data0";
            argv[5] = 0;
    
     
    
     
9.  含有可变形参的函数声明方式，传入一个initializer\_list类型的形参，此类型里的成员都是常量不可改变；第二种方式是省略符形参；详细见198页
    
        void err_msg(initializer_list<string>il)
        {
            for(auto beg=il.begin(); beg!=il.end();++begin)
            { cout<<*beg<<" ";}
            cout<<endl;
        }
        
        // 省略符形参
        
        void foo(param_list, ...);  //逗号可以省略
        void foo(...);

### 6.3 返回类型和return语句 ###

1.  返回局部对象的引用是错误的；同样，返回局部对象的指针也是错误的
2.  调用运算符（）的优先级与点运算符.和箭头运算符->一样，同时满足左结合律因此下面语句可以正常执行
    
        auto sz = shorterString(s1,s2).size();
    
     
3.  函数的返回类型决定函数调用是否为左值。调用一个返回引用的函数得到左值，可以为其结果赋值（常量引用例外）
    
        //这里函数返回的是char型的引用，作为左值可以为其赋值
        char &get_val(string &str, string::size_type ix)
        { return str[ix];}
        
        int main()
        { 
            string s("a value");
            cout<<s<<endl;
            get_val(s,0) = 'A';
            cout<<s<<endl;
            return 0;
        }
    
     
4.  函数返回值允许用列表初始化， return \{1,2,3,4\} 合法，只要其类型符合返回值的类型；
5.  声明一个返回数组指针的函数有两种方式，阅读理解顺序从内到外，从右到左
    
        int (*func(int i))[10] ;//函数func有一个参数i，返回一个指针，指向有10个int型的数组
        auto func(int i) -> int(*)[10] ; //㞑置返回类型，显式提示真正的返回类型

### 6.4 函数重载 ###

1.  不允许两个函数除了返回类型外其他所有的要素都相同；对于重载的函数来说，他们应该在形参数量或者形参类型上有所不同；
2.  顶层const不影响传入函数的对象。一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开来
    
        int lookup(phone);
        int lookup(const phone);  //重复声明
    
    形参如果是某种类型的指针或者引用，则可以通过const区分函数重载，此时的const是底层的
    
        record lookup(account&);
        record lookup(const account&);  //新函数，作用于常量引用
        record lookup(account*); //新函数，作用于指向account的指针
        record lookup(const account*); //新函数，作用于指向常量的指针
    
     
3.  同名函数声明置于局部作用于内实现的是隐藏而不是重载，详见210页

### 6.5 特殊用途语言特性 ###

1.  一旦某个形参被赋予了默认值，那么它后面所有的形参都必须有默认值；
2.  多次声明一个函数是合法的，但是在给定的作用域中一个形参只能被赋予一次默认实参；换句话说，函数的后续声明只能为之前没有默认值的形参添加默认实参，而且该形参右侧的所有形参必须都有默认值；
3.  局部变量不能作为默认实参
    
        typedef string::size_type sz;
        sz wd = 80;
        char def = ' ';
        sz ht();
        string screen(sz = ht(), sz = wd, char = def);
        string window = screen();  //调用 screen(ht(), 80, ' ')
        void f2()    //函数局部作用域
        {
            def = '*';        //修改了外部定义的def值
            sz wd = 100;        //隐藏了外层定义的wd,但是没有改变默认值
            window = screen();    //调用screen(ht(), 80, '*')
        }
    
     
4.  constexpr函数不一定返回常量表达式，当constexpr函数实参是常量表达式时其返回值为常量表达式，实参不是是返回的就不是常量表达式；内联函数和constexpr函数可以多次定义，但是对于给定的内联函数或者constexpr函数来说，它的多个定义必须完全一致，因此这两个函数通常定义在头文件中；
5.  assert是预处理宏，定义在<cassert>头文件中，它的名字由预处理器管理因此不需要提供using assert或者std::assert； 很多头文件都包含了<cassert>,因此即使你没有直接包含cassert，它也有可能通过其他途径包含在程序中；
6.  NDEBUG预处理变量用于调试时检查，详见216页

### 6.6 函数匹配 ###

1.  函数匹配的过程分3步，第一步确定候选函数，即找到同名的重载函数；第二步确定可行函数，匹配实参数量类型和形参数量类型；第三步寻找最佳匹配，完美匹配参数数量和类型的优先级最高，其次是可以类型转换的参数；当无法找到完美匹配的函数时编译器最终将因为调用具有二义性而拒绝请求；详见218页；
2.  实参类型转换排序等级 a,精准匹配， b通过const转换实现的匹配， c通过类型提升实现的匹配， d通过算术类型转换或者指针转换实现的匹配， e通过类类型转换实现的匹配；从a到e优先级依次降低；

### 6.7 函数指针 ###

1.  当我们把函数名作为一个值使用时，该函数自动地转换成指针
    
        pf = lengthCompare;    //pf指向名为lengthCompare的函数
        pf = &lenghtCompare;     //等价的赋值语句：取地址符可选
    
    可以用指向函数的指针调用该函数，无需提前解引用指针
    
        bool b1 = pf("hello","goodbye");
        bool b2 = (*pf)("hello","goodbye");
        bool b3 = lengthCompare("hello","goodbye");
        //以上三种调用等价
    
     
2.  把函数直接作为实参使用，此时它会自动转换成指针；直接使用函数指针闲的冗长繁琐，因此可以使用类型别名（using操作）和decltype简化写函数指针的代码
3.  返回指向函数的指针，建议用㞑置返回类型的方式，显示的声明太复杂不容易看懂；
    
        int(*f1(int))(int* int);
        auto f1(int) -> int(*)(int*,int);
        //以上两种声明方式等价，返回指向参数为(int*,int)，返回值为int的函数指针