【C++提高编程-06】----C++之STL-函数对象、谓词、仿函数

34889d2e7fec4a02bb0ae3a22b011a2a.png

🎩 欢迎来到技术探索的奇幻世界👨‍💻

📜 个人主页：@一伦明悦-CSDN博客

✍🏻 作者简介： C++软件开发、Python机器学习爱好者

🗣️ 互动与支持：💬评论      👍🏻点赞      📂收藏     👀关注+

如果文章有所帮助，欢迎留下您宝贵的评论，

点赞加收藏支持我，点击关注，一起进步！

前言

        在C++中，STL（Standard Template Library）中的函数对象（function object）、谓词（predicate）和仿函数（functor）是关键概念，用于实现通用算法的灵活性和可定制性。

正文

01-函数对象

       函数对象概念

       概念： 重载函数调用操作符的类，其对象常称为函数对象 函数对象使用重载的()时，行为类似函数调用，也叫仿函数

       本质： 函数对象(仿函数)是一个类，不是一个函数

       函数对象使用

       特点： 函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值

       函数对象超出普通函数的概念

       函数对象可以有自己的状态

       函数对象可以作为参数传递

        下面给出具体代码：代码演示了C++中函数对象的基本用法及其特性：

  1. MyAdd 类：

    • MyAdd 是一个函数对象类，重载了 operator()，使其能够像函数一样被调用。
    • operator() 接受两个 int 类型的参数，并返回它们的和。
    • 在 test01 函数中，展示了如何创建 MyAdd 的实例 myadd 并调用它来执行加法操作。

  2. MyPrint 类：

    • MyPrint 类也是一个函数对象类，同样重载了 operator()。
    • operator() 接受一个 string 类型的参数 test，并将其输出到标准输出流。
    • MyPrint 类内部还定义了一个 count 成员变量，用于统计 operator() 被调用的次数。
    • 在 test02 函数中，展示了如何创建 MyPrint 的实例 myPrint，并重复调用它来打印消息，并最后输出调用次数。
  3. test03 函数：
    • test03 函数展示了如何将函数对象作为参数传递给另一个函数。
    • 在 main 函数中调用了 test03，它首先创建了 MyPrint 的实例 myPrint。
    • 然后调用 doPrint 函数，并将 myPrint 对象和一个 string 参数 "Hello C++" 传递给它。
    • doPrint 函数内部调用了传入的 MyPrint 对象的 operator()，输出了 "Hello C++"，并递增了 count。

        函数对象的优势在于它们可以像普通函数一样调用，并且可以保持自己的状态。这使得它们比简单的函数指针或Lambda表达式更为灵活，特别适合于需要重复调用和状态管理的场景，例如在算法中作为自定义操作的手段。

#include<iostream>
using namespace std;
#include<string>


class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}

};

void test01()
{
	// 1、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
	MyAdd myadd;
	cout << myadd(10, 10) << endl;

}


//2、函数对象可以有自己的状态
class MyPrint
{
public:
	MyPrint()
	{
		count = 0;
	}
	void operator()(string test)
	{
		cout<<test<<endl;
		count++; //统计使用次数
	}
	int count; //内部自己的状态
};
void test02()
{
	MyPrint myPrint;
	myPrint("hello world");
	myPrint("hello world");
	myPrint("hello world");
	cout << "myPrint调用次数为： " << myPrint.count << endl;
}
//3、函数对象可以作为参数传递
void doPrint(MyPrint &mp, string test)
{
	mp(test);
}

void test03()
{
	MyPrint myPrint;
	doPrint(myPrint, "Hello C++");
}



int main() {

	
	//test01();
	//test02();
    test03();
	system("pause");
	return 0;
}

02-一元谓词

        概念： 返回bool类型的仿函数称为谓词

        如果operator()接受一个参数，那么叫做一元谓词

        如果operator()接受两个参数，那么叫做二元谓词

代码如下：这段代码演示了如何使用函数对象（谓词）作为算法 std::find_if 的参数来查找符合特定条件的元素。

  1. 结构体 GreaterFive 的定义：

    • GreaterFive 是一个结构体，它实现了函数调用操作符 operator()。
    • operator() 接受一个 int 类型的参数 val，并返回一个布尔值，表示该值是否大于5。
    struct GreaterFive {
    bool operator()(int val) {
        return val > 5;
    }
};

    这里的 GreaterFive 是一个一元谓词，因为它只接受一个参数。

  2. 函数 test01()：

    • test01() 函数创建了一个 vector<int> 容器 v，并填充了0到9的整数。
    • 使用了 STL 中的 std::find_if 算法来查找第一个满足 GreaterFive() 函数对象条件的元素。
    void test01() {
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
    if (it == v.end()) {
        cout << "没找到!" << endl;
    }
    else {
        cout << "找到:" << *it << endl;
    }
}
    • find_if 接受三个参数：容器的起始迭代器 v.begin()、容器的结束迭代器 v.end()，以及一个谓词 GreaterFive()。
    • find_if 会从容器的开始位置到结束位置遍历每个元素，并调用 GreaterFive() 的 operator() 来判断是否大于5。
    • 如果找到符合条件的元素，find_if 返回该元素的迭代器；如果遍历结束没有找到，则返回 v.end()。

  3. main() 函数：

    • main() 函数调用了 test01() 来执行测试。
  • test01() 中的 find_if 首先会传入 GreaterFive() 谓词对象，并对 v 中的每个元素调用 GreaterFive 的 operator()。
  • 如果找到第一个大于5的元素，将输出其值；如果未找到符合条件的元素，输出 “没找到!”。

        这段代码展示了函数对象作为谓词在STL算法中的应用。谓词允许我们灵活地定义条件，用于算法中的判断和筛选操作，使得算法更加通用和可复用。

#include<iostream>
using namespace std;
#include <vector>
#include <algorithm>
//1.一元谓词
struct GreaterFive {
	bool operator()(int val) {
		return val > 5;
	}
};
void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
	if (it == v.end()) {
		cout << "没找到!" << endl;
	}
	else {
		cout << "找到:" << *it << endl;
	}
}
int main() {
	test01();
	system("pause");
	return 0;
}

03-二元谓词

        概念： 返回bool类型的仿函数称为谓词

        如果operator()接受一个参数，那么叫做一元谓词

        如果operator()接受两个参数，那么叫做二元谓词

        这段代码展示了在STL中如何使用二元谓词（函数对象）来改变排序算法的比较方式，并进行从大到小的排序操作。

  1. 类 MyCompare 的定义：
    • MyCompare 是一个类，重载了函数调用操作符 operator()，接受两个 int 类型参数，并返回一个布尔值。
    • operator() 实现了按照第一个参数大于第二个参数的逻辑进行比较。
class MyCompare
{
public:
    bool operator()(int num1, int num2)
    {
        return num1 > num2;
    }
};

  1. 函数 test01() 的内容：

    • test01() 函数创建了一个 vector<int> 类型的容器 v，并向其中添加了一些整数。
    • 首先通过 sort(v.begin(), v.end()) 默认排序从小到大对容器 v 进行排序，并输出排序结果。
    • 然后通过 sort(v.begin(), v.end(), MyCompare()) 使用自定义的二元谓词 MyCompare 改变排序方式为从大到小，并输出结果。

  2. 执行流程总结：

    • 第一次调用 sort 默认按从小到大排序。
    • 第二次使用 sort 时，将 MyCompare() 作为参数传入，改变排序规则为从大到小。

  3. main() 函数：

    • main() 函数调用 test01() 来执行测试。
  • 第一次排序输出结果应该是: 10 20 30 40 50
  • 第二次使用 MyCompare 作为谓词进行排序，输出结果应该是: 50 40 30 20 10

        这段代码展示了如何使用二元谓词（函数对象）来自定义比较操作，以便在STL算法中改变默认的排序方式。通过传入不同的比较函数对象，可以根据实际需求灵活地定制排序规则，使得STL算法在处理数据时更加灵活和通用。

#include <vector>
#include <algorithm>
//二元谓词
class MyCompare
{
public:
	bool operator()(int num1, int num2)
	{
		return num1 > num2;
	}
};
void test01()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(20);
	v.push_back(30);
	v.push_back(50);
	//默认从小到大
	sort(v.begin(), v.end());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	cout << "----------------------------" << endl;
	//使用函数对象改变算法策略，排序从大到小
	sort(v.begin(), v.end(), MyCompare());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

04-算术仿函数

       概念： STL内建了一些函数对象

        分类: 算术仿函数

        仿函数原型： template T plus //加法仿函数 template T minus //减法仿函数 template T multiplies //乘法仿函数 template T divides //除法仿函数 template T modulus //取模仿函数 template T negate //取反仿函数

        这段代码展示了如何使用C++标准库中提供的内建函数对象（仿函数），包括 negate 和 plus。

  1. negate 仿函数：
    • negate 是一元仿函数，它接受一个参数并返回该参数的相反数。
    • 在 test01 函数中，创建了一个 negate<int> 对象 n。
    • n(50) 调用 negate 的 operator()，返回 -50。
void test01()
{
	negate<int> n;
	cout << n(50) << endl;
}
  1. plus 仿函数：
    • plus 二元仿函数，用于执行加法操作。
    • 在 test02 函数中，创建了一个 plus<int> 对象 p。
    • p(10, 20) 调用 plus 的 operator()，返回 10 + 20 的结果，即 30。
void test02()
{
	plus<int> p;
	cout << p(10, 20) << endl;
}
  • main 函数依次调用了 test01 和 test02 函数来测试这些内建函数对象。
  • test01 函数输出 -50。
  • test02 函数输出 30。

        这段代码展示了如何使用C++标准库中提供的内建函数对象，如 negate 和 plus。这些仿函数可以用来执行一些基本的算术操作，例如取反和加法，并且可以作为算法的参数来使用，从而提供了灵活性和通用性。

#include<iostream>
using namespace std;
#include <functional>    //内建函数对象头文件


// 内建函数对象，也就是仿函数，算术仿函数

// negate  一元仿函数   取反使用

void test01()
{
	negate<int>n;
	cout << n(50) << endl;

}

// plus   二元仿函数，加法

void test02()
{
	plus<int>p;   // 这里写一个数据类型就行，因为默认另外一个和这个同类型
	cout << p(10, 20) << endl;

}


int main()
{
	test01();


	system("pause");
	return 0;
}

05-关系仿函数

       关系仿函数（Relational Function Objects）是C++标准库中的一类仿函数，用于比较两个值的大小关系。它们通常用于STL算法中的排序、查找等操作，以定义元素之间的顺序。

在C++中，常见的关系仿函数包括：

  • less<T>：对于类型 T 的值，返回 true 如果第一个参数严格小于第二个参数。
  • less_equal<T>：对于类型 T 的值，返回 true 如果第一个参数小于或等于第二个参数。
  • greater<T>：对于类型 T 的值，返回 true 如果第一个参数严格大于第二个参数。
  • greater_equal<T>：对于类型 T 的值，返回 true 如果第一个参数大于或等于第二个参数。
  • equal_to<T>：对于类型 T 的值，返回 true 如果两个参数相等。
  • not_equal_to<T>：对于类型 T 的值，返回 true 如果两个参数不相等。

        这些仿函数都是二元的，即它们接受两个参数并返回一个布尔值，根据比较结果决定大小关系。它们可以直接在STL算法中使用，例如在 sort 函数中指定排序的方式，或在 find_if 函数中指定查找的条件。

        通过使用这些关系仿函数，程序员可以根据具体的需求灵活地定义和改变元素之间的比较规则，从而使得STL算法更加通用和适用于不同的场景。

        这段代码展示了如何使用C++标准库中的内置仿函数 greater 来改变默认的排序顺序，从而实现从大到小的排序操作。

  1. 包含的头文件：

    #include <vector>
#include <deque>
#include <algorithm>
#include <functional>
    • vector 和 algorithm 是标准库中用于操作容器和算法的头文件。
    • functional 包含了内置的函数对象（仿函数）。

  2. test01() 函数：

    • 创建了一个 vector<int> 容器 v，并向其中添加了一些整数。
    • 使用循环输出容器中的元素。
    void test01()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(40);
    v.push_back(30);

    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

  3. 排序操作：

    • 使用 sort(v.begin(), v.end(), greater<int>()) 对容器 v 进行排序，其中 greater<int>() 是一个内置的仿函数，用于比较两个元素并返回较大的那个。
    • 这样排序会使容器中的元素按照从大到小的顺序排列。
    sort(v.begin(), v.end(), greater<int>());

  4. 输出排序后的结果：

    • 再次使用循环输出排序后的容器元素，验证排序结果是否正确。
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
    cout << *it << " ";
}
cout << endl;
  • main() 函数调用了 test01() 来执行测试。
  • 初始时，输出未排序的容器元素：10 20 40 30
  • 经过使用 sort 和 greater<int>() 进行排序后，输出排序后的结果：40 30 20 10

这段代码展示了如何使用C++标准库中的内置函数对象 greater，它是一个二元仿函数，用于在STL算法中实现从大到小的排序。通过这种方式，可以轻松地改变默认的排序顺序，使得STL的算法更加灵活和通用。

#include <iostream>
using namespace std;

#include <vector>
#include <deque>
#include <algorithm>
#include <functional>

void test01()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(40);
	v.push_back(30);

	for (vector<int>::iterator it = v.begin(); it != v.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;

	// 除了使用自定义仿函数排序外，还可以使用内置仿函数  greater从大到小
	sort(v.begin(), v.end(), greater<int>());


	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

}

int main() {

	test01();

	system("pause");
	return 0;
}

总结

        

  1. 函数对象（Function Object）：

    • 函数对象是一种重载了函数调用操作符 operator() 的类对象，它允许对象像函数一样被调用。
    • 在STL中，很多算法（比如排序、查找等）可以接受函数对象作为参数，以便根据自定义的逻辑进行操作。
    • 函数对象可以存储状态，因此它比简单的函数指针更灵活，可以实现更复杂的行为。
    struct MyFunctionObject {
    bool operator()(int a, int b) const {
        return a < b;
    }
};

  2. 谓词（Predicate）：

    • 谓词是一种特殊的函数对象，它返回一个布尔值，用于描述一个对象是否满足某个条件。
    • 在STL中，谓词通常用于算法中的判断条件，例如在 std::find_if 中指定一个条件来查找满足条件的元素。
    • 谓词可以是函数指针、函数对象或者Lambda表达式。
    bool IsOdd(int num) {
    return num % 2 != 0;
}

  3. 仿函数（Functor）：

    • 仿函数是一个类对象，重载了 operator()，使得它可以像函数一样被调用。
    • 仿函数提供了一种比普通函数更灵活的方式来实现一些特定的算法逻辑，因为它可以保存状态。
    • 在STL中，很多算法的参数可以接受仿函数，用来定义它们的行为。
    struct MyFunctor {
    void operator()(int value) const {
        std::cout << "Value: " << value << std::endl;
    }
};

总结来说，函数对象、谓词和仿函数都是为了在STL中增加灵活性和可复用性而设计的概念。它们允许开发人员以多种方式定制算法的行为，使得STL成为C++中强大的工具之一

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/714062.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

这 10 种架构师，不合格！

这 10 种架构师，不合格！

大家好&#xff0c;我是君哥。 架构师这个岗位是好多程序员努力的方向&#xff0c;尤其是刚毕业的时候&#xff0c;对架构师有一种崇拜感。毕竟从初级到架构要经历好几次级别飞跃。 工作时间久了&#xff0c;发现架构师这个岗位&#xff0c;其实定义非常广泛&#xff0c;根据工…
阅读更多...
linux 部署瑞数6实战(维普，药监局)sign第二部分

linux 部署瑞数6实战(维普，药监局)sign第二部分

声明 本文章中所有内容仅供学习交流使用&#xff0c;不用于其他任何目的&#xff0c;抓包内容、敏感网址、数据接口等均已做脱敏处理&#xff0c;严禁用于商业用途和非法用途&#xff0c;否则由此产生的一切后果均与作者无关&#xff01;wx …
阅读更多...
如何通过在线封装APP快速上线？小猪APP分发帮你解决难题

如何通过在线封装APP快速上线？小猪APP分发帮你解决难题

你是否曾经为了上线一款APP而头疼不已&#xff1f;开发完成后&#xff0c;封装、测试、分发&#xff0c;这些繁琐的步骤让人望而却步。别担心&#xff0c;小猪APP分发来了&#xff01;这篇文章将带你了解如何通过在线封装APP快速上线&#xff0c;并且告诉你为什么选择小猪APP分…
阅读更多...
[Linux] TCP协议介绍(3): TCP协议的“四次挥手“过程、状态分析...

[Linux] TCP协议介绍(3): TCP协议的“四次挥手“过程、状态分析...

TCP协议是面向连接的 上一篇文章简单分析了TCP通信非常重要的建立连接的"三次握手"的过程 本篇文章来分析TCP通信中同样非常重要的断开连接的"四次挥手"的过程 TCP的"四次挥手" TCP协议建立连接 需要"三次握手". "三次挥手&q…
阅读更多...
Postman下发流表至Opendaylight

Postman下发流表至Opendaylight

目录 任务目的 任务内容 实验原理 实验环境 实验过程 1、打开ODL控制器 2、网页端打开ODL控制页面 3、创建拓扑 4、Postman中查看交换机的信息 5、L2层流表下发 6、L3层流表下发 7、L4层流表下发 任务目的 1、掌握OpenFlow流表相关知识&#xff0c;理解SDN网络中L…
阅读更多...
飞书API 2-1：如何通过 API 创建文件夹？

飞书API 2-1：如何通过 API 创建文件夹？

本文探讨如何通过飞书的 API 来创建文件夹。通过 API 创建的文件夹&#xff0c;一般是放在共享空间&#xff0c;如果要放在个人空间&#xff0c;建议手动创建。 查看 API 文档 API 路径&#xff0c;可在飞书开放平台的服务端 API&#xff0c;依次查找云文档>云空间>文件…
阅读更多...
javaWeb项目-springboot+vue人事管理系统功能介绍

javaWeb项目-springboot+vue人事管理系统功能介绍

本项目源码&#xff1a;java-springbootvue人事管理系统源码说明文档资料资源-CSDN文库 项目关键技术 开发工具&#xff1a;IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7 框架&#xff1a;ssm、Springboot 前端&#xff1a;Vue、ElementUI 关键技术&#xff1a;springboot…
阅读更多...
高级人工智能复习 题目整理 中科大

高级人工智能复习 题目整理 中科大

题目整理 填空 1.准确性&#xff0c;复杂性&#xff0c;验证集 2. 3 2 n 3^{2^n} 32n 3 C 2 n m 3^{C^m_{2n}} 3C2nm​ 3 m 3^m 3m n 1 n1 n1 3. 状态 从状态s采取行动a后继续采用策略 π \pi π的收益 环境 4. 语法 语义 推理规则 5. 参与者&#xff0c;策略集&#xff…
阅读更多...
算法排序之冒泡排序及优化

算法排序之冒泡排序及优化

public class Bubbling {public static void main(String[] args) {// 定义需要排序的数组int[] arr {0,1,21,2,31,12,5,8};// 冒泡排序方法bubbleSort(arr);bubbleOptSort(arr);}/*** 冒泡排序* param arr 数组*/public static void bubbleSort(int[] arr){// i0&#xff0c;…
阅读更多...
【C语言】解决C语言报错：Format String Vulnerability

【C语言】解决C语言报错：Format String Vulnerability

文章目录 简介什么是Format String VulnerabilityFormat String Vulnerability的常见原因如何检测和调试Format String Vulnerability解决Format String Vulnerability的最佳实践详细实例解析示例1&#xff1a;直接使用不受信任的输入作为格式化字符串示例2&#xff1a;未验证格…
阅读更多...
英伟达开源最强通用模型Nemotron-4 340B：开启AI合成数据新纪元

英伟达开源最强通用模型Nemotron-4 340B：开启AI合成数据新纪元

【震撼发布】 英伟达最新力作——Nemotron-4 340B，一个拥有3400亿参数的超级通用模型，震撼登场！这不仅是技术的一大飞跃，更是AI领域的一次革命性突破！ 【性能卓越】 Nemotron-4 340B以其卓越的性能超越了Llama-3，专为合成数据而生。它将为医疗健康、金融、制造、零售等行…
阅读更多...
基于WPF技术的换热站智能监控系统09--封装水泵对象

基于WPF技术的换热站智能监控系统09--封装水泵对象

1、添加用户控件 2、编写水泵UI 控件中用到了Viewbox控件&#xff0c;Viewbox控件是WPF中一个简单的缩放工具&#xff0c;它可以帮助你放大或缩小单个元素&#xff0c;同时保持其宽高比。通过样式和属性设置&#xff0c;你可以创建出既美观又功能丰富的用户界面。在实际开发中…
阅读更多...
RabbitMQ揭秘：轻量级消息队列的优缺点全解析

RabbitMQ揭秘：轻量级消息队列的优缺点全解析

我是小米，一个喜欢分享技术的29岁程序员。如果你喜欢我的文章，欢迎关注我的微信公众号“软件求生”，获取更多技术干货！ 亲爱的读者朋友们，大家好！我是小米，一个热爱技术、喜欢分享的大哥哥。今天我们来聊聊一个在消息队列领域非常重要的工具——RabbitMQ。作为一个在通信…
阅读更多...
EasyExcel文件导出，出现有文件但没有数据的问题

EasyExcel文件导出，出现有文件但没有数据的问题

一开始由于JDK版本过高&#xff0c;我用的17&#xff0c;一直excel没有数据&#xff0c;表头也没有&#xff0c;后来摸索了好久&#xff0c;找了资料也没有&#xff0c;后来改了代码后报了一个错误&#xff08;com.alibaba.excel.exception.ExcelGenerateException: java.lang.…
阅读更多...
如何让视频有高级感 高级感视频制作方法 高级感视频怎么剪 会声会影视频剪辑制作教程 会声会影中文免费下载

如何让视频有高级感 高级感视频制作方法 高级感视频怎么剪 会声会影视频剪辑制作教程 会声会影中文免费下载

高质量视频通常具有清晰的画面、优质的音频和令人印象深刻的视觉效果。这篇文章来了解如何让视频有高级感&#xff0c;高级感视频制作方法。 一、如何让视频有高级感 要让视频有高级感&#xff0c;要注意以下几个要点&#xff1a; 1、剧本和故事性&#xff1a;一个好的剧本和…
阅读更多...
Vue主要使用-03

Vue主要使用-03

组件通讯 组件通讯也是我们需要了解的,在我们的实际开发中,我们使用的非常多,比如父组件内的数据传入到子组件,子组件的数据传入到父组件,什么是父组件什么是子组件&#xff1f;父组件内包含着我们的子组件,我们的父组件可以有多个子组件,父组件就是我们使用子组件拼接的。 …
阅读更多...
001 Spring介绍

001 Spring介绍

文章目录 特点1.方便解耦&#xff0c;简化开发2.AOP编程的支持3.声明式事务的支持4.方便程序的测试5.方便集成各种优秀框架6.降低Java EE API的使用难度7.Java源码是经典学习范例 好处什么是耦合和内聚耦合性&#xff0c;也叫耦合度&#xff0c;是对模块间关联程度的度量内聚标…
阅读更多...
如何学习VBA_3.3.3：VBA对于工作簿、工作表的一般操作

如何学习VBA_3.3.3：VBA对于工作簿、工作表的一般操作

我给VBA的定义&#xff1a;VBA是个人小型自动化处理的有效工具。利用好了&#xff0c;可以大大提高自己的劳动效率&#xff0c;而且可以提高数据处理的准确度。我推出的VBA系列教程共九套和一部VBA汉英手册&#xff0c;现在已经全部完成&#xff0c;希望大家利用、学习。 如果…
阅读更多...
嵌入式微处理器重点学习（三）

嵌入式微处理器重点学习（三）

堆栈操作 R1=0x005 R3=0x004 SP=0x80014 STMFD sp!, {r1, r3} 指令STMFD sp!, {r1, r3}是一条ARM架构中的存储多个寄存器到内存的指令，这里用于将r1和r3寄存器的内容存储到栈上。STMFD（Store Multiple Full Descending）是一种全递减模式的多寄存器存储指令，它会先将栈指针…
阅读更多...
【MATLAB】语法

【MATLAB】语法

MATLAB 基本语法(%{和%}) 赋值 函数名值&#xff1b;for for i1:10循环语句 end//while x0; sum0; while x<100sumsumx;x; end//if if x > 1f x^2 1; elsef 2 * x endswitch onum input(请输入一个数); switch num case -1 //注意case后面没有冒号disp(I am…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站