《c++ primer》第6章 函数 笔记

1.函数使用引用形参返回多个信息

给函数传入一个额外的引用形参来保存其他信息

#include <iostream>
#include <string>

using namespace std;

string::size_type find_char(const string &s, char c, string::size_type &occurs)
{
    auto ret = s.size();
    occurs = 0;
    int i = 0;

    for(decltype(ret) i = 0; i != s.size(); ++i)
    {
        if(s[i] == c)
        {
            if(ret == s.size())      //记录第一次出现的位置，只执行一次
                ret = i;
            ++occurs;
        }
    }

    return ret;
}

int main()
{
    string s;
    string::size_type occurs = 0;
    cin >> s;
    char c;
    cin >> c;
    cout << find_char(s, c, occurs) << endl;
    cout << occurs << endl;

    return 0;
    
}

2.函数参数为数组时

<1 使用标记指定数组长度

比如数组结束处添加\0..

<2使用标准库规范

void prin(const int *beg, const int *end)
{
        while(beg != end)
                ....
}

prin(begin(a), end(a));   //调用

<3 显示的传递一个数组的大小

3.指针或引用形参const

const int *i; //底层,对象是个常量

const int &j;

const int k;//顶层,地址是个常量

顶层const 作为函数的参数会被忽略，

也就是

void func(const int k);//可以传参const 也可以是非const
void func2(const int *i);
void func3(const int &i);
//把const 绑定到非const 上面就错误了
void fun(int k);
void fun2(int *k);
void fun3(int &k);
const int a = 10;
fun(a)//不报错，a是副本
fun2(&a);//报错，a是const
fun3(a);//报错，a是const

4.含有可变形参的函数

如果参数数量不定，但是参数的类型一致

可以使用c++11标准库

initializer_list

头文件#include <initializer_list>

但是注意的一点，initialzer_list里面的元素全是常量。

因为<initializer_list>含有begin 和 end， 所以可以使用范围for

//求和
#include <iostream>
#include <initializer_list>

using namespace std;

int sum(initializer_list<int> li)
{
    int sum = 0;

    //int &i ,就会报错，initializer_list里面的元素全是const
    for(const int &i : li)     //写成const说明不会改变i , 使用引用避免为副本
    {
        sum += i;
    }

    return sum;
}

int main()
{
    cout << sum({1,2,3,4,5,6,7,8,9,10}) << endl;

    return 0;
}

5.引用返回左值

#include <iostream>

using namespace std;

int &ret(int *array, int i)
{
    return array[i];
}

int main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,0};
    ret(a, 8) = 1000;                 //给返回值赋值
    for(const int &i : a)
        cout << i << endl;
}

6.什么情况下返回的引用无效，什么情况下返回的常量引用无效

返回函数内定义的对象的引用无效，修改返回的常量引用无效。

7.c++11新特性使用尾置返回类型

尾置返回类型放在函数的形参表之后，我们使用auto来代替返回类型

auto func(int i) -> int(*)[10]

或者我们知道函数返回的指针指向哪个对象，就可以使用decltype关键字声明返回类型

但是decltype并不负责把数组类型转换成对应指针，必须自己添加

#include <iostream>

using namespace std;

string (* arr(void)) [10]
{
    static string a[10] = {"1","2","3","4","5","6","7","8","9","10"};

    return &a;
}

int (* arr2(void))[10]
{
    static int a[10] = {1,2,3,4,5,6,7,8,9,0};
    return &a;
}

string (& arr3(string s))[10];

int main()
{

}

分别用类型别名，尾置返回类型，decltype来改写一个返回数组的函数

#include <iostream>

using namespace std;
using arr = string[10];


string (& arr1(string a[10]))[10];

//1.使用类型别名
arr* arr2(string a[10]);

//使用尾置返回类型
auto arr3(string a[10])->string(*)[10];

//使用decltype
string b[10];
decltype(b)* arr4(string a[10]);

int main()
{
    return 0;
}

8.const_cast 和函数重载

这个在我的另外一篇文章中也有写到。

在非const 里面调用const 版本然后去除const 的特性。

#include <iostream>

using namespace std;

const string& shortString(const string &s1, const string &s2)
{
    cout << "调用 const string &" << endl;
    return s1.size() < s2.size() ? s1 : s2;
}

string& shortString(string &s1, string &s2)
{
    cout << "调用 string &" << endl;
    auto &s = shortString(const_cast<const string&>(s1), const_cast<const string&>(s2));
    return const_cast<string &>(s);
}

int main()
{
    const string s1 = "hello";
    const string s2 = "world";
    string s3,s4;

    cin >> s3 >> s4;
    shortString(s1, s2);
    shortString(s3, s4);

    return 0;

}

9.默认实参

#include <iostream>
#include <string>

using namespace std;

typedef string::size_type st;

void scree(st hi = 20, st wi = 20, char back = 'a')
{
    cout << hi << " " << wi << " " << back << endl;
}

int main()
{
    scree(3, 3, 'a');
    scree();
}

注意：一但某个形参被赋于了默认值，它后面所有的形参都必须有默认值

char * init(int ht = 24, int wd, char bakg); //error 

调用默认实参，省略参数就行。

尽量让不太使用的实参出现在函数参数表后面

10.对于那些经常使用的函数应该指定为内敛函数
inline关键字

内敛函数可避免函数调用的开销

内敛机制用于优化规模小，流程直接，频繁调用的函数

11.constexpr修饰函数， 用于返回常量表达式

constexprt函数体内也可以有空语句，只要这些语句在运行时不执行任何操作就行。

#include <iostream>
#include <string>

using namespace std;

constexpr const string& shortString(const string &s1, const string &s2)
{
    //return s1.size() <= s2.size() ? s1 : s2;    error
    return s1;
}

int main()
{
    const string s1 = "hello";
    const string s2 = "world";
    //constexpr string s3 = "aasd";               error
    
    cout << shortString(s1, s2) << endl;

    return EXIT_SUCCESS;
}

注释的都是有错误的，constexpr函数不能在调用时计算，运行时不能执行任何操作。

12.调试帮助

assert和NDEBUG

assert(条件)  条件为真什么也不做，条件为假发出错误并打印错误

assert的行为依赖于NDEBUG预处理变量的状态。 如果定义了NDEBUG 那么assert什么也不做

定义NDEBUG能避免检查各种条件所需的运行时的开销

也可以自己使用NDEBUG编写调试代码

#include <iostream>
//#define NDEBUG                             //注意位置，NDEBUG必须写在assert.h的前面，否则不起作用
#include <assert.h>

void fun(int a = 10, int b = 20)
{
    assert(a == 9);
    std::cout << a << " " << b << std::endl;
    std::cout << __FILE__ << std::endl;
    std::cout << __LINE__ << std::endl;
    std::cout << __TIME__ << std::endl;
    std::cout << __DATE__ << std::endl;
}

int main()
{
    fun();
    return 0;
}

有#define NDEBUG 和 没有的运行结果

__FILE__存放文件名的字符串字面值

__LINE__存放当前行号的整型字面值

__TIME__存放文件编译时间的字符串字面值

__DATE__存放文件编译日期的字符串字面值

13.函数指针

#include <iostream>

using namespace std;

void func(int a, int b)
{
    cout << a << " " << b << endl;
}

int main()
{
    void (*p) (int a, int b);
    p = func;
    p(1,3);
    (*p)(1,3);
}

函数指针定义一般显得非常繁琐

所以我们可以使用typdef 和 decltype来简化

typedef bool Func(const string&, const string&);
typedef decltype(Func) *Funcp; //decltype要自己加上*，它不会自动转换成指针类型

返回指向函数的指针

要想声明一个返回函数指针的函数，最简单的方法是使用类型别名

using F = int(int *, int);       //函数类型
using FF = int(*p)(int *, int);  //函数指针类型

FF f1(int);
F* f2(int);

int(*f1(int)) (int *, int);      //也可以直接声明，f1是个有参列表，且有*说明是个指针，指针指向一个函数
auto f1(int) -> int(*)(int, int);//尾置返回类型

auto和decltype作用于函数指针类型

#include <iostream>
#include <string>

using namespace std;

int fun1(int a)
{
    int sum = 1;
    while(a-- != 0)
    {
        sum *= a;
    }

    return sum;
}

decltype(fun1)* fun3(void)
{
    cout << "调用fun1" << endl;
}

int main()
{
    fun3();

    return 0;
}