当前位置：首页 > news >正文

[C++面试] 你了解transform吗？

news 来源：原创 2025/7/28 7:35:43

层级	核心知识点
入门	基本语法、与`for_each`对比、单/双范围操作
进阶	动态扩展、原地转换、类型兼容性、异常安全
高阶	性能优化、C++20 Ranges、`transform_if`模拟

一、入门

1、描述`std::transform`的基本功能，并写出两种版本的函数原型

std::transform函数是 C++ 标准库<algorithm>头文件中的一个算法，其主要用途是对一个或两个范围的元素进行变换，并将结果存储到另一个范围中。它有两种重载形式：一种用于单范围变换，另一种用于双范围变换。

一元版本：处理单个输入范围，函数原型：

template< class InputIt, class OutputIt, class UnaryOperation >
OutputIt transform( InputIt first1, InputIt last1, OutputIt d_first, UnaryOperation unary_op );

first1和last1：定义输入范围的迭代器，指定要变换的元素范围。
d_first：输出范围的起始迭代器，用于存储变换后的结果。
unary_op：一元操作符，用于对输入范围的每个元素进行变换。

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> input = {1, 2, 3, 4, 5};std::vector<int> output(input.size());// 将一个整数向量中的每个元素乘以 2std::transform(input.begin(), input.end(), output.begin(), [](int x) {return x * 2;});return 0;
}

二元版本：处理两个输入范围，函数原型：

template< class InputIt1, class InputIt2, class OutputIt, class BinaryOperation >
OutputIt transform( InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt d_first, BinaryOperation binary_op );

first1和last1：定义第一个输入范围的迭代器。
first2：第二个输入范围的起始迭代器，其长度应至少与第一个输入范围相同。
d_first：输出范围的起始迭代器，用于存储变换后的结果。
binary_op：二元操作符，用于对两个输入范围的对应元素进行变换。

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> input1 = {1, 2, 3, 4, 5};std::vector<int> input2 = {5, 4, 3, 2, 1};std::vector<int> output(input1.size());std::transform(input1.begin(), input1.end(), input2.begin(), output.begin(), [](int x, int y) {return x + y;});return 0;
}

2、与`for_each`的区别

std::for_each：主要用于对一个范围内的每个元素执行某种操作，重点在于操作本身，通常这些操作会产生副作用，比如修改元素、打印日志等。该函数不返回经过操作后的数据，它的返回值类型是传入的可调用对象类型，且这个可调用对象的返回值类型通常为 void。
std::transform：专注于对一个或多个范围内的元素进行转换，通过返回值生成一个新的序列。它可以将转换后的结果输出到不同的容器中，常用于无副作用的纯转换操作。

template< class InputIt, class UnaryFunction >
UnaryFunction for_each( InputIt first, InputIt last, UnaryFunction f );
// first 和 last：定义输入范围的迭代器。
// f：一元可调用对象，对输入范围内的每个元素执行该操作。

#include <iostream>
#include <vector>
#include <algorithm>// 定义一个用于 for_each 的可调用对象，用于打印元素并将元素加 1
struct PrintAndIncrement {void operator()(int& num) {std::cout << "Original: " << num << std::endl;num += 1;std::cout << "After increment: " << num << std::endl;}
};// 定义一个用于 transform 的可调用对象，用于将元素乘以 2
int MultiplyByTwo(int num) {return num * 2;
}int main() {std::vector<int> numbers = {1, 2, 3, 4, 5};// 使用 std::for_each 进行带副作用的操作std::for_each(numbers.begin(), numbers.end(), PrintAndIncrement());// 重置 numbers 向量numbers = {1, 2, 3, 4, 5};std::vector<int> result(numbers.size());// 使用 std::transform 进行纯转换操作std::transform(numbers.begin(), numbers.end(), result.begin(), MultiplyByTwo);return 0;
}

二、进阶

1、如何在不预分配目标容器空间时使用`transform`？

在使用 std::transform 时，如果不提前为目标容器分配空间，直接使用普通的迭代器可能会导致未定义行为，因为迭代器可能会访问到容器外部的内存。

而使用 std::back_inserter 可以解决这个问题。std::back_inserter 是一个插入迭代器，它会在每次赋值操作时调用目标容器的 push_back 方法，这样就可以动态地向容器中添加元素，而不需要提前分配空间。

std::vector<int> results;
std::transform(src.begin(), src.end(), std::back_inserter(results), [](int x) { return x * 2; });

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>int main() {// 定义源容器std::vector<int> src = {1, 2, 3, 4, 5};// 定义目标容器，初始为空，不预分配空间std::vector<int> results;// 使用 std::transform 和 std::back_inserterstd::transform(src.begin(), src.end(), std::back_inserter(results), [](int x) {return x * 2;});return 0;
}

std::back_inserter(results) 作为输出迭代器，它会在每次赋值操作时调用 results 容器的 push_back 方法，将转换后的元素添加到 results 容器中。

2、如何用`transform`实现原地修改？可能存在哪些风险？

将目标迭代器设为输入范围的起始迭代器。

风险：若操作抛出异常，容器可能处于部分修改状态，也需确保操作不破坏元素依赖关系。

std::transform(vec.begin(), vec.end(), vec.begin(), ::toupper);  // 字符串转大写

#include <iostream>
#include <vector>
#include <algorithm>
#include <cctype>int main() {std::vector<std::string> vec = {"hello", "world", "cpp"};// 使用 std::transform 实现原地修改for (auto& str : vec) {std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c) {return std::toupper(c);});}return 0;
}

3、`ransform`是否支持输入与输出类型不同？举例说明

// 将std::string转换为哈希值：
std::vector<std::string> words {"one", "two"};
std::vector<size_t> hashes;
std::transform(words.begin(), words.end(), std::back_inserter(hashes), std::hash<std::string>{});

std::transform 是支持输入与输出类型不同的。它的设计初衷是对一个或多个范围的元素进行转换操作，最终将结果存储到另一个范围中。在这个过程中，转换操作可以将输入类型的数据转换为不同类型的输出数据，只要提供合适的转换函数即可。

三、高阶

1、如何通过自定义函数对象优化`transform`性能？

使用无状态的函数对象（如struct重载operator()），便于编译器内联优化
避免在lambda中捕获大型对象，减少拷贝开销。

无状态的函数对象是指不包含任何成员变量的函数对象。
编译器在处理无状态函数对象时，更容易进行内联优化。
内联优化是指编译器将函数调用替换为函数体本身，从而减少函数调用的开销。

#include <iostream>
#include <vector>
#include <algorithm>// 无状态的函数对象，用于计算平方
struct Square {int operator()(int x) const {return x * x;}
};int main() {std::vector<int> src = {1, 2, 3, 4, 5};std::vector<int> dest(src.size());// 使用自定义的无状态函数对象进行转换std::transform(src.begin(), src.end(), dest.begin(), Square{});return 0;
}

当使用 lambda 表达式作为转换操作时，如果捕获了大型对象，会产生拷贝开销。

#include <iostream>
#include <vector>
#include <algorithm>// 大型对象示例
struct LargeObject {int data[1000];
};int main() {std::vector<int> src = {1, 2, 3, 4, 5};std::vector<int> dest(src.size());// 避免捕获大型对象LargeObject largeObj;// 使用不捕获大型对象的 lambdastd::transform(src.begin(), src.end(), dest.begin(), [](int x) {return x * 2;});// 输出结果for (int num : dest) {std::cout << num << " ";}std::cout << std::endl;return 0;
}

在 std::transform 调用中，使用的 lambda 表达式没有捕获 LargeObject 类型的对象，避免了拷贝开销。如果确实需要使用大型对象，可以考虑使用引用捕获，如 [&largeObj](int x) { /* 使用 largeObj */ }，但要注意引用的生命周期问题。

2、C++20的`ranges::transform`有何改进？

C++20引入范围语法，简化迭代器传递。支持更简洁的链式操作（如与views组合）。

#include <iostream>
#include <vector>
#include <ranges>int main() {std::vector<int> src = {1, 2, 3, 4, 5};std::vector<int> dest(src.size());std::ranges::transform(src, dest.begin(), [](int x) {return x * 2;});return 0;
}

#include <iostream>
#include <vector>
#include <ranges>int main() {std::vector<int> src = {1, 2, 3, 4, 5};// 链式操作：先过滤出偶数，再将其乘以 2auto result = src | std::views::filter([](int x) { return x % 2 == 0; })| std::views::transform([](int x) { return x * 2; });return 0;
}

std::views::filter 是一个视图适配器，用于过滤出满足条件的元素。
std::views::transform 是另一个视图适配器，用于对元素进行转换。
通过使用管道操作符 |，可以将多个视图适配器组合在一起，形成一个链式操作。整个操作是惰性计算的，只有在遍历 result 范围时才会实际执行过滤和转换操作，避免了创建中间容器，提高了性能和代码的简洁性。

3、STL未提供`transform_if`，如何模拟其功能？

法1：先转换再过滤

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>int main() {std::vector<int> src = { -1, 2, -3, 4, -5 };std::vector<int> filtered;// 先进行转换：使用 std::transform 对 src 中的每个元素进行转换。如果元素大于 0，则将其乘以 2；否则，将其设置为 -1。std::transform(src.begin(), src.end(), std::back_inserter(filtered), [](int x) { return x > 0 ? x * 2 : -1; });// 过滤掉不符合条件的元素：使用 std::remove 和 erase 组合来移除值为 -1 的元素// std::remove 将值为 -1 的元素移到容器末尾，并返回一个指向新的逻辑末尾的迭代器，然后 erase 函数删除这些元素。filtered.erase(std::remove(filtered.begin(), filtered.end(), -1), filtered.end());return 0;
}

法2：结合std::copy_if与transform

int main() {std::vector<int> src = { -1, 2, -3, 4, -5 };std::vector<int> temp;std::vector<int> result;// 过滤出符合条件的元素std::copy_if(src.begin(), src.end(), std::back_inserter(temp), [](int x) { return x > 0; });// 对符合条件的元素进行转换std::transform(temp.begin(), temp.end(), std::back_inserter(result), [](int x) { return x * 2; });return 0;
}

过滤操作：使用 std::copy_if 将 src 中大于 0 的元素复制到 temp 容器中。
转换操作：使用 std::transform 对 temp 中的元素进行转换，将每个元素乘以 2

法3：使用std::accumulate手动处理条件

#include <iostream>
#include <vector>
#include <numeric>int main() {std::vector<int> src = { -1, 2, -3, 4, -5 };std::vector<int> result;// 使用 std::accumulate 手动处理std::accumulate(src.begin(), src.end(), std::back_inserter(result), [](auto& out, int x) {if (x > 0) {out = x * 2;++out;}return out;});// 输出结果for (int num : result) {std::cout << num << " ";}std::cout << std::endl;return 0;
}

std::accumulate 会遍历 src 中的每个元素，根据条件判断是否进行转换。如果元素大于 0，则将其乘以 2 并添加到 result 容器中。

4、在使用`std::transform`时，如何处理可能出现的异常？请给出一个考虑异常安全性的示例

在使用std::transform时，异常可能来自于传入的操作符（如 lambda 函数、函数对象等）。

为了处理可能出现的异常，我们可以在操作符内部进行异常处理，或者在调用std::transform的地方进行异常捕获。

#include <iostream>
#include <vector>
#include <algorithm>
#include <stdexcept>std::string convert_string(const std::string& str) {// convert_string函数用于将输入字符串转换为大写，如果输入字符串为空，则抛出std::invalid_argument异常if (str.empty()) {throw std::invalid_argument("Input string is empty");}std::string result = str;for (char& c : result) {c = std::toupper(c);}return result;
}int main() {std::vector<std::string> input = {"hello", "", "world"};std::vector<std::string> output(input.size());try {std::transform(input.begin(), input.end(), output.begin(), convert_string);for (const std::string& str : output) {std::cout << str << " ";}std::cout << std::endl;} catch (const std::exception& e) {std::cerr << "Exception caught: " << e.what() << std::endl;}return 0;
}

一、入门

1、描述std::transform的基本功能，并写出两种版本的函数原型

2、与for_each的区别

二、进阶

2、如何用transform实现原地修改？可能存在哪些风险？

3、ransform是否支持输入与输出类型不同？举例说明

三、高阶

2、C++20的ranges::transform有何改进？

3、STL未提供transform_if，如何模拟其功能？

4、 在使用std::transform时，如何处理可能出现的异常？请给出一个考虑异常安全性的示例

相关文章：