向算法传递函数

默认情况下,泛型算法还实现了另外一个版本,就是接受一个额外的参数。比如sort函数,接受第三个参数,第三个参数是一个谓词。 谓词就是一个可调用的表达式,其返回值结果是一个能用作条件的值。 标准库算法所使用的谓词分为两类: 一元谓词(unary predicate,意味着它们只接受单一参数)和二元谓词(binary predicate,意味着它们有两个参数)。 接受谓词参数的算法对输入序列中的元素调用谓词。因此,元素类型必须能转换为谓词的参数类型。 我们可以暂且将谓词理解为函数 我们利用谓词,修改sort的排序规则

bool isShort(const string &s1, const string &s2)
{
    return s1.size() < s2.size();
}

上述代码将规则修改为按长度有小到大排序 接下来我们实现一个函数调用sort并传递参数isShort

void use_predicate()
{
    vector<string> words = {"hello", "za", "zack", "no matter", "what"};
    sort(words.begin(), words.end(), isShort);
    for (auto it = words.begin(); it != words.end(); it++)
    {
        cout << *it << endl;
    }
}

上面的函数输出

za
zack
what
hello
no matter

lambda表达式

lambda表达式提供了类似函数的功能,可以理解为一个匿名函数,通过传递参数和捕获外部变量的引用,值等方式完成一些逻辑处理。 一个lambda表达式表示一个可调用的代码单元。 我们可以将其理解为一个未命名的内联函数。 与任何函数类似,一个lambda具有一个返回类型、一个参数列表和一个函数体。 但与函数不同,lambda可能定义在函数内部。 一个lambda表达式具有如下形式

[capture list](parameter list) -> return type {function body}

capture list表示捕获列表,如果lambda表达式定义在函数内部,可以通过capture list 捕获该函数的局部变量的引用或者值。 return type、parameter list和function body与任何普通函数一样,分别表示返回类型、参数列表和函数体。 我们可以忽略返回类型,lambda可以根据返回值自己推导返回类型。

   auto f = []()
    { return 42; };

此例中,我们定义了一个可调用对象f,它不接受参数,返回42。lambda的调用方式与普通函数的调用方式相同,都是使用调用运算符:

 cout << " f is " << f() << endl;

如果lambda的函数体包含任何单一return语句之外的内容,且未指定返回类型,则返回void。 我们将isShorter函数定义为lambda表达式

  [](const string &s1, const string &s2) -> bool
    { return s1.size() < s2.size(); };

我们可以通过调用stable_sort进行排序,长度相同的单词维持原序列.

vector<string> words = {"hello", "za", "zack", "no matter", "what"};
    stable_sort(words.begin(), words.end(), [](const string &s1, const string &s2) -> bool
                { return s1.size() < s2.size(); });

我们打印words

for (auto it = words.begin(); it != words.end(); it++)
    {
        cout << *it << endl;
    }

输出如下

za
zack
what
hello
no matter

我们用lambda表达式的捕获功能,实现一个函数,查找长度大于指定数值的单词个数。 我们先实现一个将单词排序并去除重复单词的函数

void erase_dup(vector<string> &words)
{
    //先将words中的词语排序
    sort(words.begin(), words.end());
    // unique会移动元素,将不重复的元素放在前边,重复的放在后边
    // unique返回不重复的最后一个元素的位置
    const auto uniqueiter = unique(words.begin(), words.end());
    //调用erase将重复的元素删除
    words.erase(uniqueiter, words.end());
}

接下来我们实现biggers函数,返回大于指定长度sz的单词的个数

int use_bigger(int sz)
{
    vector<string> words = {"hello", "za", "zack", "no matter", "what"};
    //先排序去除重复单词
    erase_dup(words);
    //再稳定排序,按照长度有小到大
    stable_sort(words.begin(), words.end(), [](const string &s1, const string &s2) -> bool
                { return s1.size() < s2.size(); });
    auto findit = find_if(words.begin(), words.end(), [sz](const string &s)
                          { return s.size() > sz; });

    return words.end() - findit;
}

我们测试下

    cout << "count is " << use_bigger(3) << endl;
    cout << "count is " << use_bigger(5) << endl;
    cout << "count is " << use_bigger(10) << endl;

程序输出如下

count is 4
count is 1
count is 0

可以看出长度大于3的单词有4个,长度大于5的有1个,长度大于10的有0个。 我们通过lambda表达式[sz]的方式捕获了use_bigger的形参sz。 如果我们要将长度大于sz的单词全部打印出来,可以采用foreach函数,该函数接受三个参数,前两个是迭代器表示遍历的范围,第三个是一个表达式,表示对每个元素的操作。我们完善use_bigger函数

int use_bigger(int sz)
{
    vector<string> words = {"hello", "za", "zack", "no matter", "what"};
    //先排序去除重复单词
    erase_dup(words);
    //再稳定排序,按照长度有小到大
    stable_sort(words.begin(), words.end(), [](const string &s1, const string &s2) -> bool
                { return s1.size() < s2.size(); });
    auto findit = find_if(words.begin(), words.end(), [sz](const string &s)
                          { return s.size() > sz; });
    for_each(findit, words.end(), [](const string &s)
             { cout << s << " "; });
    cout << endl;
    return words.end() - findit;
}

lambda捕获类型

lambda捕获分为值捕获和引用捕获。 lambda采用值捕获的方式。与传值参数类似,采用值捕获的前提是变量可以拷贝。 与参数不同,被捕获的变量的值是在lambda创建时拷贝,而不是调用时拷贝。

void lambda_catch()
{
    int val = 10;
    auto fn = [val]
    { return val; };
    val = 200;
    auto fv = fn();
    cout << "fv is " << fv << endl;
}

上述代码fv会输出10,因为fn捕获的是val的值,在lambda表达式创建时就捕获了val,此时val值为10. 如果采用引用方式捕获

void lambda_catch_r()
{
    int val = 10;
    auto fn = [&val]
    { return val; };
    val = 200;
    auto fv = fn();
    cout << "fv is " << fv << endl;
}

此时输出fv is 200, 因为fn捕获的是val的引用。 我们可以从一个函数返回lambda,此lambda不能包含引用捕获。因为如果lambda包含了函数局部变量的引用,当次局部变量被释放后,lambda调用会出现崩溃问题。

捕获一个普通变量,如int、string或其他非指针类型,通常可以采用简单的值捕获方式。 在此情况下,只需关注变量在捕获时是否有我们所需的值就可以了。 如果我们捕获一个指针或迭代器,或采用引用捕获方式,就必须确保在lambda执行时,绑定到迭代器、指针或引用的对象仍然存在。 而且,需要保证对象具有预期的值。 在lambda从创建到它执行的这段时间内,可能有代码改变绑定的对象的值。 也就是说,在指针(或引用)被捕获的时刻,绑定的对象的值是我们所期望的,但在lambda执行时,该对象的值可能已经完全不同了。 一般来说,我们应该尽量减少捕获的数据量,来避免潜在的捕获导致的问题。而且,如果可能的话,应该避免捕获指针或引用。

隐式捕获

为了指示编译器推断捕获列表,应在捕获列表中写一个&或=。&告诉编译器采用捕获引用方式,=则表示采用值捕获方式。 比如我们修改use_bigger函数,参数增加一个ostream和char的分隔符,在use_bigger内部利用for_each调用

int use_bigger2(ostream &os, char c, int sz)
{
    vector<string> words = {"hello", "za", "zack", "no matter", "what"};
    //先排序去除重复单词
    erase_dup(words);
    //再稳定排序,按照长度有小到大
    stable_sort(words.begin(), words.end(), [](const string &s1, const string &s2) -> bool
                { return s1.size() < s2.size(); });
    auto findit = find_if(words.begin(), words.end(), [sz](const string &s)
                          { return s.size() > sz; });
    // os 按照引用方式捕获,其余变量c 通过= 值方式隐士捕获。
    for_each(findit, words.end(), [=, &os](const string &s)
             { os << s << c; });

    // c 按照值的方式捕获,其余按照引用方式捕获。
    for_each(findit, words.end(), [&, c](const string &s)
             { os << s << c; });
    cout << endl;
    return words.end() - findit;
}

上述代码两个for_each通过不同的隐式方式捕获局部变量。

mutable改变值

默认情况下,值捕获的变量,lambda不会改变其值。lambda可以声明mutable,这样可以修改捕获的变量值。

void mutalble_lam()
{
    int val = 100;
    auto fn = [val]() mutable
    {
        return ++val;
    };

    cout << "val is " << val << endl;

    cout << "fn val is " << fn() << endl;

    val = 200;
    cout << "val is " << val << endl;

    cout << "fn val is " << fn() << endl;
}

程序输出

val is 100
fn val is 101
val is 200
fn val is 102

fn捕获val的值,因为fn是mutable所以可以修改val,但不会影响外界的val。

lambda返回类型

我们要做一个返回序列中数值的绝对值的函数

void rt_lambda()
{
    vector<int> nums = {-1, 2, 3, -5, 6, 7, -9};
    transform(nums.begin(), nums.end(), nums.begin(), [](int a)
              { return a < 0 ? -a : a; });
    for_each(nums.begin(), nums.end(), [](int a)
             { cout << a << endl; });
}

通过transform将nums中的数值全部变为其绝对值。transform前两个参数表示输入序列,第三个参数表示写入的目的序列,如果目的序列迭代器和输入序列开始的迭代器相同,则表示transform序列全部元素。lambda表达式并没有写返回值类型,但是是一个三目运算符的表达式,所以lambda可以推断返回类型。如果将lambda表达式写成如下会报错。

[](int a){ if(a<0) return -a; else return a; }

此时我们修改上面的lambda表达式,明确写出返回类型为int

 transform(nums.begin(), nums.end(), nums.begin(), [](int a) -> int
              { if (a < 0)  return -a; else return a; });

bind绑定参数

bind的形式为

auto newCallable = bind(callable, arg_list);

newCallable本身是一个可调用对象,arg_list是一个逗号分隔的参数列表,对应给定的callable的参数。 即,当我们调用newCallable时,newCallable会调用callable,并传递给它arg_list中的参数。

arg_list中的参数可能包含形如_n的名字,其中n是一个整数。这些参数是“占位符”,表示newCallable的参数,它们占据了传递给newCallable的参数的“位置”。 数值n表示生成的可调用对象中参数的位置:_1为newCallable的第一个参数,_2为第二个参数,依此类推。 我们先实现一个判断字符串长度的函数

bool check_size(const string &str, int sz)
{
    if (str.size() > sz)
    {
        return true;
    }

    return false;
}

check_size如果字符串str的长度大于sz就返回true,否则就返回false。 接下来用bind操作生成一个新的函数,只接受一个sz参数。 使用bind函数要包含头文件functional,也需要使用using namespace std::placeholders

void calsize_count()
{
    string str = "hello";
    //将check_size第一个参数绑定给bind_check
    auto bind_check = bind(check_size, _1, 6);
    //相当于调用check_size(str,6)
    bool bck = bind_check(str);
    if (bck)
    {
        cout << "check res is true" << endl;
    }
    else
    {
        cout << "check res is false" << endl;
    }
}

通过bind将check_size第一个参数绑定给bind_check,第二个参数为6 所以调用bind_check(str)相当于调用check_size(str,6)。 我们可以用bind方式实现find_if的查找,因为find_if接受的谓词只能有一个参数,所以通过bind将check_size生成为单参数函数。

int use_bigger3(ostream &os, char c, int sz)
{
    vector<string> words = {"hello", "za", "zack", "no matter", "what"};
    //先排序去除重复单词
    erase_dup(words);
    //再稳定排序,按照长度有小到大
    stable_sort(words.begin(), words.end(), [](const string &s1, const string &s2) -> bool
                { return s1.size() < s2.size(); });
    auto findit = find_if(words.begin(), words.end(), bind(check_size, _1, sz));

    // c 按照值的方式捕获,其余按照引用方式捕获。
    for_each(findit, words.end(), [&, c](const string &s)
             { os << s << c; });
    cout << endl;
    return words.end() - findit;
}

通过bind生成新的函数传递给find_if就可以使用了。 bind极大地方便了泛型编程的可扩展性。

results matching ""

    No results matching ""