0
点赞
收藏
分享

微信扫一扫

JVM 一些常见问题Q&A

梦为马 2024-06-17 阅读 12
c++开发语言

34889d2e7fec4a02bb0ae3a22b011a2a.png

前言

正文

01-遍历算法之for_each用法

下面给出具体代码分析应用过程

这段代码展示了如何使用 for_each 算法进行遍历操作，分别使用普通函数和函数对象作为操作体。让我简要解释一下这部分代码：

  1. 头文件包含：

    #include <algorithm>
#include <vector>

    这里包含了使用到的标准库头文件 <algorithm> 和 <vector>。

  2. 普通函数 print01：

    void print01(int val)
{
    cout << val << " ";
}

    print01 是一个普通函数，用于打印传入的整数 val。

  3. 函数对象 print02：

    class print02
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

    print02 是一个函数对象（也称为仿函数），重载了函数调用运算符 operator()，用于打印传入的整数 val。

  4. test01 函数：

    void test01() {
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    // 使用 for_each 算法调用普通函数 print01
    for_each(v.begin(), v.end(), print01);
    cout << endl;

    // 使用 for_each 算法调用函数对象 print02
    for_each(v.begin(), v.end(), print02());
    cout << endl;
}
    • 在 test01 函数中，首先创建了一个 vector<int> 容器 v，并将整数 0 到 9 添加到容器中。
    • 然后使用 for_each 算法分别调用了 print01 和 print02 函数对象，对容器 v 中的每个元素执行打印操作。

  5. main 函数：

    int main() {
    test01();
    system("pause");
    return 0;
}

    main 函数调用了 test01 函数，展示了 for_each 算法的基本用法和不同操作体的应用。

总结：

  • 这段代码演示了如何使用 for_each 算法对容器进行遍历操作，可以通过普通函数或函数对象来定义具体的操作。
  • 函数对象的使用使得可以在一个地方定义多个不同的操作，增加了代码的灵活性和可复用性。
  • for_each 算法不会修改容器中的元素，只是对每个元素执行指定的操作，这符合算法的设计初衷。

通过这样的方式，可以简化遍历操作的代码实现，并使代码更加清晰和易于维护。

#include <algorithm>
#include <vector>
//普通函数
void print01(int val)
{
	cout << val << " ";
}
//函数对象
class print02
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
//for_each算法基本用法
void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//遍历算法
	for_each(v.begin(), v.end(), print01);
	cout << endl;
	for_each(v.begin(), v.end(), print02());
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

02-遍历算法之transform用法

下面给出代码分析应用过程：

这段代码演示了如何使用 transform 算法来对一个容器中的元素进行转换，并将结果存储到另一个容器中。让我来简要解释一下：

  1. 头文件包含：

    #include <vector>
#include <algorithm>

    这里包含了使用到的标准库头文件 <vector> 和 <algorithm>。

  2. 函数对象 TransForm：

    class TransForm
{
public:
    int operator()(int val)
    {
        return val;
    }
};

    TransForm 是一个函数对象（仿函数），重载了函数调用运算符 operator()，用于对传入的整数 val 进行转换操作。在这个例子中，它实际上是一个恒等函数，返回原始的输入值。

  3. 函数对象 MyPrint：

    class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

    MyPrint 是另一个函数对象，用于打印传入的整数 val。

  4. test01 函数：

    void test01()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    vector<int> vTarget; // 目标容器
    vTarget.resize(v.size()); // 目标容器需要提前开辟空间

    // 使用 transform 算法对容器 v 中的每个元素应用 TransForm，并将结果存储到 vTarget 中
    transform(v.begin(), v.end(), vTarget.begin(), TransForm());

    // 使用 for_each 算法打印 vTarget 中的每个元素
    for_each(vTarget.begin(), vTarget.end(), MyPrint());
}
    • 在 test01 函数中，首先创建了一个 vector<int> 容器 v，并向其中插入整数 0 到 9。
    • 创建了另一个 vector<int> 容器 vTarget 作为目标容器，并调整其大小以匹配 v 的大小。
    • 使用 transform 算法对容器 v 中的每个元素应用 TransForm 函数对象，并将结果存储到 vTarget 中。
    • 最后，使用 for_each 算法和 MyPrint 函数对象打印 vTarget 中的每个元素。

  5. main 函数：

    int main() {
    test01();
    system("pause");
    return 0;
}

    main 函数调用了 test01 函数，展示了 transform 算法的基本用法和将操作结果存储到另一个容器的实际应用。

总结：

  • transform 算法能够对一个容器中的元素进行操作，并将结果存储到另一个容器或同一容器的不同位置，比如示例中的 vTarget。
  • 使用函数对象（如 TransForm 和 MyPrint）可以灵活定义操作，增强代码的可复用性和可维护性。
  • 需要注意的是，目标容器在使用 transform 算法之前需要预先分配足够的空间，以确保存储结果的正确性。

通过这样的方式，可以有效地进行数据转换和处理，使代码更加清晰和模块化。

#include<vector>
#include<algorithm>
//常用遍历算法 搬运 transform
class TransForm
{
public:
	int operator()(int val)
	{
		return val;
	}
};
class MyPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	vector<int>vTarget; //目标容器
	vTarget.resize(v.size()); // 目标容器需要提前开辟空间
	transform(v.begin(), v.end(), vTarget.begin(), TransForm());
	for_each(vTarget.begin(), vTarget.end(), MyPrint());
}
int main() {
	test01();
	system("pause");
	return 0;
}

03-算术生成算法之accumulate用法

 下面给出具体代码分析应用过程：

这段代码展示了如何使用 accumulate 算法来计算整数向量中所有元素的累加和。让我来简要解释一下：

  1. 头文件包含：

    #include <numeric>
#include <vector>

    这里包含了使用到的标准库头文件 <numeric> 和 <vector>。

  2. test01 函数：

    void test01()
{
    vector<int> v;
    for (int i = 0; i <= 100; i++) {
        v.push_back(i);
    }
    int total = accumulate(v.begin(), v.end(), 0);
    cout << "total = " << total << endl;
}
    • 在 test01 函数中，首先创建了一个 vector<int> 容器 v，并使用循环将整数 0 到 100 插入到向量中。
    • 调用 accumulate 算法计算了容器 v 中所有元素的累加和。参数解释如下：
      • v.begin() 和 v.end() 表示累加的范围是从容器 v 的开头到末尾（不包括末尾）。
      • 0 是累加的初始值，即从0开始累加。
    • 将计算得到的总和 total 输出到标准输出流 cout 中。

  3. main 函数：

    int main() {
    test01();
    system("pause");
    return 0;
}

    main 函数调用了 test01 函数，展示了 accumulate 算法的使用方式和计算结果的输出。

总结：

  • accumulate 算法能够方便地对容器中的元素进行累加操作，从而计算它们的总和。
  • 初始值 0 确保了即使容器为空，也能正确返回初始值作为累加结果。
  • 使用 accumulate 算法可以避免显式使用循环来计算累加和，简化了代码并提高了可读性。

通过这样的方式，可以快速、有效地处理需要累加操作的情况，适用于各种数据类型和复杂度的累加需求。

#include <numeric>
#include <vector>
void test01()
{
	vector<int> v;
	for (int i = 0; i <= 100; i++) {
		v.push_back(i);
	}
	int total = accumulate(v.begin(), v.end(), 0);
	cout << "total = " << total << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

04-算术生成算法之fill用法

 下面给出具体代码分析应用过程：

这段代码演示了如何使用 fill 算法来填充整数向量中的所有元素为指定的值。让我来简要解释一下：

  1. 头文件包含：

    #include <numeric>
#include <vector>
#include <algorithm>
#include <iostream>

    这里包含了使用到的标准库头文件 <numeric>, <vector>, <algorithm> 和 <iostream>。

  2. 自定义函数对象 myPrint：

    class myPrint {
public:
    void operator()(int val) {
        std::cout << val << " ";
    }
};

    myPrint 是一个重载了函数调用运算符 () 的类，用于在 for_each 算法中打印每个元素的值。

  3. test01 函数：

    void test01() {
    std::vector<int> v;
    v.resize(10);  // 调整向量大小为10个元素

    // 使用 fill 算法将向量 v 中的所有元素设置为 100
    std::fill(v.begin(), v.end(), 100);

    // 使用 for_each 算法和自定义的 myPrint 函数对象打印向量中的每个元素
    std::for_each(v.begin(), v.end(), myPrint());
    std::cout << std::endl;
}
    • 在 test01 函数中，首先创建了一个大小为 10 的整数向量 v。
    • 使用 fill 算法将向量 v 中的所有元素设置为 100。v.begin() 表示填充的起始位置，v.end() 表示填充的结束位置（不包含在范围内）。
    • 使用 for_each 算法和自定义的 myPrint 函数对象，遍历打印向量 v 中的每个元素值。

  4. main 函数：

    int main() {
    test01();
    system("pause");
    return 0;
}

    main 函数调用了 test01 函数，展示了 fill 算法的使用方式和填充后的输出结果。

总结：

  • fill 算法通过指定的值将容器中的指定范围内的所有元素进行填充。
  • 在本例中，fill 将整数向量 v 中的所有元素设置为 100。
  • 使用函数对象 myPrint 可以在遍历过程中自定义操作，这里用于打印每个元素。
  • fill 是初始化或重置容器元素的有效工具，能够简化代码并提高可读性。

通过这样的方式，可以快速、方便地对容器中的元素进行填充操作，适用于各种数据类型和填充需求。

#include <numeric>
#include <vector>
#include <algorithm>
class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	vector<int> v;
	v.resize(10);
	//填充
	fill(v.begin(), v.end(), 100);
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结  

举报

相关推荐

dedecms一些常见问题

dede分页网站制作侧边栏虚拟化云计算

思科认证 | 思科认证考试常见问题Q&A

官网知识模块网络工程师思科认证考试认证

List操作的一些常见问题

设计模式桥接模式

Java代码规范和一些常见问题

代码规范javaxml成员方法JAVAJavaScript前端开发

Android 一些环境常见问题处理汇总

contextandroideclipse错误处理编程语言

#yyds干货盘点# MySQL 一些常见问题

数据隔离级别mvcMySQL数据库

关于站立会议的一些常见问题

敏捷开发项目经理搜索Python后端开发

CSS笔记（四） 一些常见问题及技巧

csscss3前端大前端web

关于MCU核心板的一些常见问题

jvmjava学习开发语言

总结了一些指针易出错的常见问题（一）

算法javac++开发语言函数指针系统/运维
0 条评论