C++ STL count_if实战：用Lambda表达式和函数对象，实现灵活条件计数

在C++开发中，数据统计是常见需求。STL的count_if算法提供了一种优雅的解决方案，但很多开发者仅停留在基础用法，未能充分利用现代C++特性。本文将带你探索如何用Lambda表达式和函数对象，让条件计数变得更灵活、更强大。

1. 从基础到现代：count_if的进化之路

传统C++中，count_if通常搭配独立函数或函数指针使用。例如统计一个整数列表中所有偶数：

bool isEven(int n) {
    return n % 2 == 0;
}

vector<int> numbers = {1, 2, 3, 4, 5};
int evenCount = count_if(numbers.begin(), numbers.end(), isEven);

这种方式虽然可行，但存在几个明显问题：

• 函数定义与使用分离，代码可读性差
• 难以捕获上下文变量
• 无法内联优化，性能可能受影响

C++11引入的Lambda表达式彻底改变了这一局面。同样的功能可以这样实现：

vector<int> numbers = {1, 2, 3, 4, 5};
int evenCount = count_if(numbers.begin(), numbers.end(), 
    [](int n) { return n % 2 == 0; });

Lambda的优势显而易见：

• 代码更紧凑，逻辑一目了然
• 可以捕获局部变量
• 编译器更容易优化

2. Lambda表达式的进阶用法

2.1 捕获列表的灵活运用

Lambda的真正威力在于其捕获能力。考虑一个实际场景：统计员工列表中薪资高于部门平均值的员工数量。

struct Employee {
    string name;
    string department;
    double salary;
};

vector<Employee> employees = {...};

// 计算市场部平均薪资
double avgSalary = accumulate(employees.begin(), employees.end(), 0.0,
    [](double sum, const Employee& e) {
        return sum + e.salary;
    }) / employees.size();

// 统计薪资高于平均值的员工
int aboveAvgCount = count_if(employees.begin(), employees.end(),
    [avgSalary](const Employee& e) {
        return e.salary > avgSalary;
    });

这里，Lambda通过值捕获([avgSalary])使用了外部计算的avgSalary变量，使条件判断变得非常简单。

2.2 通用Lambda(C++14)

C++14引入的通用Lambda进一步增强了灵活性：

auto isGreaterThan = [](auto threshold) {
    return [threshold](auto value) {
        return value > threshold;
    };
};

vector<int> nums = {1, 2, 3, 4, 5};
vector<double> prices = {10.5, 20.3, 15.7};

int countNums = count_if(nums.begin(), nums.end(), isGreaterThan(3));
int countPrices = count_if(prices.begin(), prices.end(), isGreaterThan(15.0));

这种技术特别适合需要相同逻辑但类型不同的场景。

3. 函数对象：更强大的条件封装

当条件逻辑变得复杂时，函数对象(仿函数)是更好的选择。函数对象是一个类，它重载了operator()，可以像函数一样被调用。

3.1 基本函数对象实现

假设我们需要统计满足多个条件的员工：

class EmployeeFilter {
    optional<string> dept;
    optional<double> minSalary;
    optional<int> minAge;
public:
    EmployeeFilter& setDepartment(string department) {
        dept = department;
        return *this;
    }
    
    EmployeeFilter& setMinSalary(double salary) {
        minSalary = salary;
        return *this;
    }
    
    EmployeeFilter& setMinAge(int age) {
        minAge = age;
        return *this;
    }
    
    bool operator()(const Employee& emp) const {
        if (dept && emp.department != *dept) return false;
        if (minSalary && emp.salary < *minSalary) return false;
        if (minAge && emp.age < *minAge) return false;
        return true;
    }
};

// 使用示例
EmployeeFilter filter;
filter.setDepartment("IT").setMinSalary(50000);

int itHighEarners = count_if(employees.begin(), employees.end(), filter);

这种方式的优势在于：

• 条件可以动态组合
• 代码可读性高
• 易于维护和扩展

3.2 函数对象与Lambda的结合

C++11后，函数对象常与Lambda结合使用，形成更强大的模式：

auto makeDepartmentFilter = [](string department) {
    return [department](const Employee& emp) {
        return emp.department == department;
    };
};

auto itEmployees = count_if(employees.begin(), employees.end(), 
    makeDepartmentFilter("IT"));

4. 实战案例：复杂条件统计系统

让我们构建一个完整的员工统计系统，展示现代C++条件计数的强大能力。

4.1 数据结构定义

struct Employee {
    string id;
    string name;
    string department;
    int age;
    double salary;
    vector<string> skills;
};

vector<Employee> employees = {
    {"001", "Alice", "Engineering", 32, 85000.0, {"C++", "Python", "Linux"}},
    {"002", "Bob", "Marketing", 28, 75000.0, {"SEO", "Analytics"}},
    // 更多员工数据...
};

4.2 多条件组合统计

// 统计工程部30岁以上且掌握C++的员工
int seniorCppDevs = count_if(employees.begin(), employees.end(),
    [](const Employee& emp) {
        return emp.department == "Engineering" &&
               emp.age > 30 &&
               find(emp.skills.begin(), emp.skills.end(), "C++") != emp.skills.end();
    });

// 使用函数对象实现更灵活的过滤
class SkillFilter {
    string skill;
    int minProficiency; // 假设有熟练度评分
public:
    SkillFilter(string s, int mp) : skill(s), minProficiency(mp) {}
    
    bool operator()(const Employee& emp) const {
        // 实际项目中可能有更复杂的判断逻辑
        return find(emp.skills.begin(), emp.skills.end(), skill) != emp.skills.end();
    }
};

SkillFilter pythonFilter("Python", 3);
int pythonExperts = count_if(employees.begin(), employees.end(), pythonFilter);

4.3 性能优化技巧

当处理大型数据集时，性能变得关键。以下是一些优化建议：

1. 尽量使用const引用捕获：避免不必要的拷贝

   double salaryThreshold = 100000.0;
   int highEarners = count_if(employees.begin(), employees.end(),
       [&salaryThreshold](const Employee& emp) {
           return emp.salary > salaryThreshold;
       });
   

2. 简单Lambda优先：编译器更容易内联优化

   // 好：简单Lambda
   int youngEmployees = count_if(employees.begin(), employees.end(),
       [](const Employee& emp) { return emp.age < 30; });
   
   // 不好：复杂逻辑放在Lambda中
   int complexCount = count_if(employees.begin(), employees.end(),
       [](const Employee& emp) {
           // 多行复杂逻辑
           if (...) {
               // ...
           }
           // ...
       });
   

3. 考虑谓词预计算：对于不变的条件，可以预先计算

   auto isEngineering = [](const Employee& emp) {
       return emp.department == "Engineering";
   };
   
   // 多次使用同一个谓词
   int engineeringCount = count_if(employees.begin(), employees.end(), isEngineering);
   auto engineeringIt = find_if(employees.begin(), employees.end(), isEngineering);
   

5. C++17/20新特性应用

现代C++标准引入了更多强大特性，可以进一步提升count_if的使用体验。

5.1 结构化绑定(C++17)

vector<tuple<string, int, double>> employeeTuples = {
    {"Alice", 32, 85000.0},
    {"Bob", 28, 75000.0},
    // ...
};

int highSalaryYoung = count_if(employeeTuples.begin(), employeeTuples.end(),
    [](const auto& emp) {
        const auto& [name, age, salary] = emp;
        return age < 30 && salary > 80000.0;
    });

5.2 范围for与count_if结合

C++20的范围库使代码更简洁：

#include <ranges>

int youngCount = count_if(employees | views::filter([](const Employee& e) {
    return e.age < 30;
}), [](const Employee& e) {
    return e.salary > 50000.0;
});

5.3 概念约束(C++20)

确保谓词符合要求：

template <typename P>
requires std::predicate<P, Employee>
int countEmployees(const vector<Employee>& employees, P predicate) {
    return count_if(employees.begin(), employees.end(), predicate);
}

在实际项目中，根据团队习惯和代码复杂度，选择最适合的技术组合。对于简单条件，Lambda通常是最佳选择；对于复杂或可重用的条件逻辑，函数对象可能更合适。