泛型算法

|
vector<int> scores = {85, 92, 100, 78, 95, 88};
int targetScore = 100;
 
// 在scores中查找目标分数
auto result = find(scores.cbegin(), scores.cend(), targetScore);
 
// 检查是否找到
if (result != scores.cend()) {
    cout << "找到满分学生，分数为：" << *result << endl;
} else {
    cout << "没有学生获得满分" << endl;
}

|
list<string> studentNames = {"张三", "李四", "王五", "赵六"};
string target = "李四";
auto found = find(studentNames.cbegin(), studentNames.cend(), target);

|
int grades[] = {89, 76, 95, 82, 90, 88};
int targetGrade = 95;
int* result = find(begin(grades), end(grades), targetGrade);

|
vector<int> examScores = {85, 92, 85, 78, 92, 85, 88};
int targetScore = 85;
int occurrences = count(examScores.cbegin(), examScores.cend(), targetScore);
cout << "分数" << targetScore << "出现了" << occurrences <<

|
vector<double> monthlyExpenses = {1200.0, 1150.0, 1300.0, 980.0, 1100.0};
double totalExpense = accumulate(monthlyExpenses.cbegin(), 
                                monthlyExpenses.cend(), 0.0);
cout << "总支出：" << totalExpense << " 元" << endl;

|
vector<string> courseNames = {"数学", "物理", "化学", "生物"};
string courselist = accumulate(courseNames.cbegin(), courseNames.cend(), 
                              string("课程列表："));
cout << courselist << endl;  // 输出：课程列表：数学物理化学生物

|
vector<string> class1Students = {"张三", "李四", "王五"};
vector<string> class2Students = {"张三", "李四", "王五"};
 
// 检查两个班级的学生名单是否相同
bool isSame = equal(class1Students.cbegin(), class1Students.cbegin(), 
                   class2Students.cbegin());

|
vector<int> scores(10);  // 创建包含10个元素的vector
fill(scores.begin(), scores.end(), 0);  // 将所有元素设置为0
 
// 或者只设置前半部分
fill(scores.begin(), scores.begin() + scores.size()/2, 95);

|
vector<int> testScores(20);
fill_n(testScores.begin(), 10, 85);  // 将前10个元素设置为85

|
vector<int> emptyScores;  // 空vector
// 危险！试图向空容器写入10个元素
fill_n(emptyScores.begin(), 10, 100);  // 运行时错误

|
vector<int> studentIDs;  // 空vector
auto inserter = back_inserter(studentIDs);
*inserter = 20210001;  // 等价于studentIDs.push_back(20210001)
*inserter = 20210002;  // 等价于studentIDs.push_back(20210002)

|
vector<int> scores;  // 空vector
fill_n(back_inserter(scores), 15, 90);  // 安全地添加15个值为90的元素

|
int originalGrades[] = {88, 92, 76, 95, 83, 90, 87, 91, 79, 85};
int copyGrades[10];  // 确保目标数组有足够的空间
 
auto endIterator = copy(begin(originalGrades), end(originalGrades), copyGrades);
// endIterator指向copyGrades中最后一个被复制元素的下一个位置

|
list<string> subjects = {"数学", "英语", "数学", "物理", "数学"};
vector<string> newSubjects;
 
// 将所有"数学"替换为"高等数学"，结果存入newSubjects
replace_copy(subjects.cbegin(), subjects.cend(),
            back_inserter(newSubjects), "数学", "高等数学");
 
// subjects保持不变，newSubjects包含替换后的结果

|
vector<string> textWords = {"编程", "学习", "C++", "编程", "算法", 
                           "学习", "数据结构", "C++", "编程"};

|
sort(textWords.begin(), textWords.end());
// textWords现在是：{"C++", "C++", "学习", "学习", "数据结构", "算法", "编程", "编程", "编程"}

|
auto endUnique = unique(textWords.begin(), textWords.end());
// textWords现在是：{"C++", "学习", "数据结构", "算法", "编程", ???, ???, ???, ???}
//                                                      ↑
//                                                   endUnique

|
textWords.erase(endUnique, textWords.end());
// 现在textWords只包含唯一的词汇：{"C++", "学习", "数据结构", "算法", "编程"}

|
void eliminateDuplicates(vector<string> &words) {
    sort(words.begin(), words.end());
    auto endUnique = unique(words.begin(), words.end());
    words.erase(endUnique, words.end());
}

|
bool isShorterWord(const string &word1, const string &word2) {
    return word1.size() < word2.size();
}

|
vector<string> vocabulary = {"编程", "C++", "学习", "数据结构", "算法"};
sort(vocabulary.begin(), vocabulary.end(), isShorterWord);
// 结果按长度排序：{"C++", "学习", "算法", "编程", "数据结构"}

|
eliminateDuplicates(vocabulary);  // 去重并按字母排序
stable_sort(vocabulary.begin(), vocabulary.end(), isShorterWord);
// 结果：先按长度排序，相同长度的单词保持字母顺序

|
[捕获列表](参数列表) -> 返回类型 { 函数体 }

|
auto simpleFunction = []{ return 42; };
cout << simpleFunction() << endl;  // 输出：42

|
auto lengthComparator = [](const string &a, const string &b) {
    return a.size() < b.size();
};
 
sort(vocabulary.begin(), vocabulary.end(), lengthComparator);

|
void analyzeVocabulary(vector<string> &words, vector<string>::size_type minLength) {
    eliminateDuplicates(words);
    stable_sort(words.begin(), words.end(), 
                [](const string &a, const string &b) {
                    return a.size() < b.

|
void demonstrateValueCapture() {
    size_t count = 42;
    auto counter = [count]{ return count; };
    
    count = 0;  // 修改局部变量
    auto result = counter();  // result仍然是42
    cout << "结果：" << result << endl;  // 输出：结果：42
}

|
void demonstrateReferenceCapture() {
    size_t count = 42;
    auto counter = [&count]{ return count; };
    
    count = 0;  // 修改局部变量
    auto result = counter();  // result是0
    cout << "结果：" << result << endl;  // 输出：结果：0
}

|
void printToFile(vector<string> &words, ostream &outputStream, char separator = ' ') {
    for_each(words.begin(), words.end(),
            [&outputStream, separator](const string &word) {
                outputStream << word << separator;
            });

|
void demonstrateImplicitCapture(vector<string> &words, size_t minLength) {
    // 隐式值捕获
    auto longWordFilter = [=](const string &word) {
        return word.size() >= minLength;  // minLength被自动捕获
    };
    
    // 也可以混合使用
    ostream &output = cout;

|
void demonstrateMutableLambda() {
    size_t counter = 0;
    auto incrementer = [counter]() mutable {
        return ++counter;  // 修改捕获的副本
    };
    
    counter = 10;
    cout << incrementer() << endl;  // 输出：1（修改的是副本）
    cout << counter << endl;        // 输出：10（原变量未变）

|
vector<int> numbers = {-5, -2, 0, 3, -1, 4, -3, 6};
 
// 错误：编译器推断返回类型为void
// transform(numbers.begin(), numbers.end(), numbers.begin(),
//          [](int n) { if (n < 0) return -n; else return n; });
 
// 正确：明确指定返回类型
transform(numbers.begin(), numbers.end(), numbers.begin(),
         [](int

|
bool check_size(const string &s, string::size_type sz)
{
    return s.size() >= sz;
}

|
auto newCallable = bind(callable, arg_list);

|
auto checkWordLength = bind(check_size, _1, 5);
// checkWordLength接受一个string参数，相当于调用check_size(参数, 5)
 
string testWord = "编程";
bool result = checkWordLength(testWord);  // 等价于check_size(testWord, 5)

|
auto wc = find_if(words.begin(), words.end(),
[sz](const string &a)
{ return a.size() >= sz; });

|
using namespace std::placeholders;

|
// 假设有一个比较函数
bool isLonger(const string &s1, const string &s2) {
    return s1.size() > s2.size();
}
 
// 反转参数顺序
sort(words.begin(), words.end(), bind(isLonger, _2, _1));

|
void printWord(ostream &os, const string &word, char separator) {
    os << word << separator;
}
 
// 错误：不能复制ostream
// for_each(words.begin(), words.end(), bind(printWord, cout, _1, ' '));
 
// 正确：使用ref传递引用
for_each(words.begin(), words.end(), 
         bind(printWord, ref(cout), _1, ' '));

|
list<int> originalList = {1, 2, 3, 4};
list<int> backList, frontList, insertList;
 
// 使用back_inserter
copy(originalList.cbegin(), originalList.cend(), back_inserter(backList));
// backList现在是：{1, 2, 3, 4}
 
// 使用front_inserter
copy(originalList.cbegin(), originalList.cend(), front_inserter(frontList));
// frontList现在是：{4, 3, 2, 1}（顺序相反）
 
// 使用inserter

|
istream_iterator<int> intReader(cin);    // 从cin读取int
istream_iterator<int> eof;               // 尾后迭代器
vector<int> numbers;
 
while (intReader != eof) {
    numbers.push_back(*intReader++);
}

|
istream_iterator<int> intReader(cin), eof;
vector<int> numbers(intReader, eof);  // 从cin读取直到EOF或错误

|
istream_iterator<int> input(cin), eof;
cout << "数字总和：" << accumulate(input, eof, 0) << endl;

|
ostream_iterator<int> intWriter(cout, " ");  // 每个int后跟一个空格
ostream_iterator<string> stringWriter(cout, "\n");  // 每个string后跟换行

|
vector<int> scores = {85, 92, 78, 96, 88};
copy(scores.begin(), scores.end(), intWriter);
cout << endl;

|
istream_iterator<string> wordInput(cin), eof;
ostream_iterator<string> wordOutput(cout, " ");
 
vector<string> words(wordInput, eof);  // 读取所有单词
sort(words.begin(), words.end());      // 排序
copy(words.begin(), words.end(), wordOutput);

|
vector<int> numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
// 反向输出所有元素
for (auto rit = numbers.crbegin(); rit != numbers.crend(); ++rit) {
    cout << *

|
vector<string> words = {"apple", "banana", "cherry", "date"};
sort(words.rbegin(), words.rend());  // 降序排序
// words现在是：{"date", "cherry", "banana", "apple"}

|
string text = "programming,algorithm,data,structure";
auto comma = find(text.cbegin(), text.cend(), ',');
cout << string(text.cbegin(), comma) << endl;  // 输出：programming

|
auto rcomma = find(text.crbegin(), text.crend(), ',');

|
cout << string(rcomma.base(), text.cend()) << endl;  // 输出：structure

|
list<int> numbers1 = {1, 3, 5, 7, 9};
list<int> numbers2 = {2, 4, 6, 8, 10};
 
// 使用list特定的merge算法
numbers1.merge(numbers2);  // numbers2变为空，所有元素移到numbers1中
// numbers1现在包含：{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 
// 删除所有偶数
numbers1.remove_if([](

|
list<string> taskList1 = {"任务A", "任务B"};
list<string> taskList2 = {"任务C", "任务D", "任务E"};
 
// 将taskList2的所有元素移动到taskList1的开头
taskList1.splice(taskList1.begin(), taskList2);
// taskList1: {"任务C", "任务D", "任务E", "任务A", "任务B"}
// taskList2: {} (空)
 
list<string> urgentTasks = {"紧急任务1"