【C++提高编程-09】----C++ STL之常用排序算法

最新推荐文章于 2024-07-17 20:58:27 发布
最新推荐文章于 2024-07-17 20:58:27 发布
阅读量1.1k 收藏 15
点赞数 33
分类专栏： C++ 提高编程学习 文章标签： c++ 开发语言 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59951855/article/details/139725146
版权

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

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

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

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

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

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

前言

       STL（Standard Template Library）是C++标准库的一部分，提供了丰富的数据结构和算法，用于处理数据和实现常见的计算任务。STL中的算法分为几类，包括遍历算法、修改算法、排序算法、查找算法、数值算法等，每类算法都有其特定的应用场景和功能。

正文

01-排序算法之sort用法     

sort 算法详解

语法

template <class RandomAccessIterator>
void sort (RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare>
void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
  • RandomAccessIterator：表示随机访问迭代器类型，用于指定排序范围。
  • first：表示排序范围的起始位置。
  • last：表示排序范围的结束位置，不包含在范围内。
  • comp：可选参数，用于指定排序的比较函数对象。

参数

  • first：排序范围的起始位置。
  • last：排序范围的结束位置，不包含在范围内。
  • comp：可选参数，用于指定排序的比较函数对象。如果不提供此参数，默认使用 < 运算符进行比较。

功能

sort 算法用于对范围 [first, last) 内的元素进行排序，默认以升序方式排列。

返回值

  • sort 函数没有返回值，直接在原始范围上进行排序操作。

示例

以下是使用 sort 算法对整数向量进行排序的示例：

#include <iostream>
#include <vector>
#include <algorithm> // 包含 sort 函数

int main() {
    std::vector<int> numbers = {5, 2, 8, 3, 1, 4};

    // 使用 sort 对向量进行升序排序
    std::sort(numbers.begin(), numbers.end());

    std::cout << "升序排序后的结果为: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果将是 “升序排序后的结果为: 1 2 3 4 5 8”。在这个例子中，sort 函数对向量 numbers 中的元素进行了升序排序，并输出排序后的结果。

注意事项

  • sort 算法默认使用 < 运算符进行比较，可通过提供自定义的比较函数对象 comp 进行特定排序。
  • 对于自定义数据类型，确保比较函数对象 comp 或重载 < 运算符，以确保算法能正确比较对象。

通过 sort 算法，可以方便地对容器内的元素进行排序操作，适用于各种数据结构和排序需求。

        这段代码演示了C++中对vector容器内元素进行排序的基本用法，并展示了如何使用自定义的比较函数来实现不同的排序顺序。

  1. 包含头文件和定义函数

    • #include <algorithm>：包含了标准库中的排序算法 sort 和 greater。
    • #include <vector>：包含了使用的容器 vector。
    • void myPrint(int val)：定义了一个简单的函数 myPrint，用于输出整数值。

  2. 定义测试函数 test01()

    • 创建了一个整数类型的 vector v，并向其中添加了几个整数元素。
    • 使用 sort(v.begin(), v.end()) 对 vector v 进行升序排序（默认情况下）。
    • 使用 for_each(v.begin(), v.end(), myPrint) 遍历输出排序后的元素，函数 myPrint 负责打印每个元素。
    • 执行 cout << endl; 输出换行。

  3. 反向排序示例

    • 使用 sort(v.begin(), v.end(), greater<int>()) 对 vector v 进行降序排序。greater<int>() 是一个函数对象，表示按照大于号 (>) 的方式进行比较。
    • 再次使用 for_each(v.begin(), v.end(), myPrint) 输出降序排序后的元素。
    • 执行 cout << endl; 输出换行。

  4. 主函数 main()

    • 调用 test01() 函数来执行上述排序和输出操作。
    • 最后使用 system("pause"); 在控制台暂停程序的执行，等待用户按下任意键结束程序。

这段代码通过展示 sort 函数的基本使用，演示了如何实现升序和降序排序，以及如何自定义比较函数来满足不同的排序需求。

#include <algorithm>
#include <vector>
void myPrint(int val)
{
	cout << val << " ";
}
void test01() {
	vector<int> v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(20);
	v.push_back(40);
	//sort默认从小到大排序
	sort(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
	//从大到小排序
	sort(v.begin(), v.end(), greater<int>());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

02-排序算法之random_shuffle用法     

random_shuffle 算法详解

语法

template <class RandomAccessIterator>
void random_shuffle (RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class RandomNumberGenerator>
void random_shuffle (RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator&& rand);
  • RandomAccessIterator：表示随机访问迭代器类型，用于指定要打乱的范围。
  • first：表示打乱范围的起始位置。
  • last：表示打乱范围的结束位置，不包含在范围内。
  • rand：可选参数，表示用于生成随机数的随机数生成器对象。

参数

  • first：打乱范围的起始位置。
  • last：打乱范围的结束位置，不包含在范围内。
  • rand：可选参数，用于指定随机数生成器对象。如果不提供此参数，默认使用 std::default_random_engine 生成随机数。

功能

random_shuffle 算法用于对范围 [first, last) 内的元素进行随机打乱。

返回值

  • random_shuffle 函数没有返回值，直接在原始范围上进行元素打乱操作。

示例

以下是使用 random_shuffle 算法对整数向量进行随机打乱的示例：

#include <iostream>
#include <vector>
#include <algorithm> // 包含 random_shuffle 函数
#include <random> // 包含随机数生成器

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // 使用 random_shuffle 对向量进行随机打乱
    std::random_shuffle(numbers.begin(), numbers.end());

    std::cout << "随机打乱后的结果为: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果将是随机的顺序，例如 “随机打乱后的结果为: 5 7 1 4 3 2 8 9 10 6”。在这个例子中，random_shuffle 函数对向量 numbers 中的元素进行了随机打乱，并输出打乱后的结果。

注意事项

  • random_shuffle 算法使用默认的随机数生成器来生成随机数。如果需要定制化的随机数生成器，可以提供自定义的随机数生成器对象。
  • 对于自定义数据类型，确保实现了迭代器的随机访问能力，以便算法能正确操作范围内的元素。

通过 random_shuffle 算法，可以方便地对容器内的元素进行随机打乱操作，适用于各种需要随机顺序的场景。

这段代码展示了如何使用 C++ 的 random_shuffle 算法对 vector 容器内的元素进行随机打乱，并输出打乱后的结果。

  1. 包含头文件和定义类

    • #include <algorithm>：包含了标准库中的 random_shuffle 算法。
    • #include <vector>：包含了使用的容器 vector。
    • #include <ctime>：包含了 time 函数，用于获取当前时间。
    • #include <cstdlib>：包含了 srand 和 rand 函数，用于设置和获取随机数种子。

  2. 定义类 myPrint

    • class myPrint：定义了一个仿函数 (function object)，其中重载了 operator()，用于输出整数值。

  3. 定义测试函数 test01()

    • srand((unsigned int)time(NULL));：通过调用 srand 函数设置随机数种子，使用当前时间作为种子，确保每次运行得到不同的随机结果。
    • 创建了一个整数类型的 vector v，并使用 for 循环向其中添加了整数元素 0 到 9。
    • 使用 for_each(v.begin(), v.end(), myPrint()) 遍历输出 vector 中的元素，函数对象 myPrint 负责打印每个元素。
    • 执行 cout << endl; 输出换行。

  4. 随机打乱示例

    • 使用 random_shuffle(v.begin(), v.end()) 对 vector v 中的元素进行随机打乱。
    • 再次使用 for_each(v.begin(), v.end(), myPrint()) 输出打乱后的元素。
    • 执行 cout << endl; 输出换行。

  5. 主函数 main()

    • 调用 test01() 函数来执行上述随机打乱和输出操作。
    • 使用 system("pause"); 在控制台暂停程序的执行，等待用户按下任意键结束程序。

这段代码通过调用 random_shuffle 函数实现了对 vector 容器内元素的随机打乱，展示了如何利用随机数种子确保每次打乱结果的随机性。

#include <algorithm>
#include <vector>
#include <ctime>
class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	srand((unsigned int)time(NULL));
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
	//打乱顺序
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

03-排序算法之merge用法     

merge 算法详解

语法

template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
                      InputIterator2 first2, InputIterator2 last2,
                      OutputIterator result);
  • InputIterator1：表示第一个有序序列的迭代器类型。
  • InputIterator2：表示第二个有序序列的迭代器类型。
  • OutputIterator：表示目标序列的迭代器类型。

参数

  • first1：第一个有序序列的起始位置。
  • last1：第一个有序序列的结束位置（不包含在范围内）。
  • first2：第二个有序序列的起始位置。
  • last2：第二个有序序列的结束位置（不包含在范围内）。
  • result：目标序列的起始位置，用于存储合并后的有序序列。

功能

merge 算法用于将两个已排序的序列合并为一个新的有序序列，并存储到目标序列中。

返回值

  • merge 函数返回一个迭代器，指向目标序列中的末尾位置（合并后序列的下一个位置）。

示例

以下是使用 merge 算法将两个已排序的向量合并为一个新的有序向量的示例：

#include <iostream>
#include <vector>
#include <algorithm> // 包含 merge 函数

int main() {
    std::vector<int> v1 = {1, 3, 5, 7, 9};
    std::vector<int> v2 = {2, 4, 6, 8, 10};
    std::vector<int> merged(v1.size() + v2.size());

    // 使用 merge 将 v1 和 v2 合并为 merged
    std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), merged.begin());

    std::cout << "合并后的有序序列为: ";
    for (int num : merged) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果将是合并后的有序序列，例如 “合并后的有序序列为: 1 2 3 4 5 6 7 8 9 10”。在这个例子中，merge 函数将两个已排序的向量 v1 和 v2 合并为一个新的有序向量 merged。

注意事项

  • merge 算法要求输入序列必须是已排序的，否则结果将不符合预期。
  • 如果输入序列有重复元素，merge 算法会保持这些重复元素的顺序。
  • 目标序列 result 的长度必须足够大，能够容纳合并后的所有元素，否则可能导致未定义行为。

通过 merge 算法，可以方便地将两个已排序的序列合并为一个新的有序序列，适用于各种需要合并排序结果的场景。

这段代码展示了如何使用 C++ 的 merge 算法将两个已排序的 vector 合并到一个新的目标 vector 中，并通过自定义的 myPrint 函数对象输出合并后的结果。

代码解释

  1. 包含头文件和定义类

    #include <algorithm>  // 包含 merge 算法
#include <vector>
#include <iostream>   // 包含 cout 和 endl
using namespace std;  // 使用标准命名空间
    • #include <algorithm>：包含了标准库中的 merge 算法。
    • #include <vector>：包含了使用的容器 vector。
    • #include <iostream>：用于标准输出 cout 和换行 endl。
    • using namespace std;：使用标准库的命名空间，避免每次使用标准库中的元素时都需要加上 std:: 前缀。

  2. 定义类 myPrint

    class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};
    • myPrint 类是一个函数对象，重载了 operator()，用于输出整数值 val，并在每个值后面添加空格。

  3. 定义测试函数 test01()

    void test01()
{
    vector<int> v1;
    vector<int> v2;

    // 向 v1 和 v2 中添加元素
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 1);
    }

    vector<int> vtarget;
    // 目标容器 vtarget 需要提前开辟空间
    vtarget.resize(v1.size() + v2.size());

    // 合并两个有序序列 v1 和 v2 到 vtarget 中
    merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vtarget.begin());

    // 使用 for_each 和 myPrint 输出合并后的结果
    for_each(vtarget.begin(), vtarget.end(), myPrint());
    cout << endl;
}
    • 创建了两个 vector 容器 v1 和 v2，分别存储整数序列 {0, 1, 2, ..., 9} 和 {1, 2, 3, ..., 10}。
    • 创建了一个目标容器 vtarget，使用 resize 函数提前为其分配了足够的空间，以便存储合并后的结果。
    • 调用 merge 函数，将 v1 和 v2 中的元素合并到 vtarget 中。
    • 使用 for_each 算法遍历 vtarget，并利用 myPrint 函数对象输出每个元素。

  4. 主函数 main()

    int main() {
    test01();
    system("pause");
    return 0;
}
    • 在 main 函数中调用 test01() 来执行上述合并和输出操作。
    • 使用 system("pause") 让程序在控制台暂停，等待用户按任意键结束程序的执行。

总结

这段代码展示了如何利用 merge 算法将两个已排序的 vector 合并成一个新的有序 vector，并通过自定义的函数对象 myPrint 输出合并后的结果。使用 resize 来提前分配空间，确保目标容器能够容纳所有合并后的元素，是 merge 算法使用的必要步骤之一。

#include <algorithm>
#include <vector>
class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
		v2.push_back(i + 1);
	}
	vector<int> vtarget;
	//目标容器需要提前开辟空间
	vtarget.resize(v1.size() + v2.size());
	//合并 需要两个有序序列
	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vtarget.begin());
	for_each(vtarget.begin(), vtarget.end(), myPrint());
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

04-排序算法之reverse用法     

排序算法之reverse用法详细解释一下

reverse 算法详解

语法

template <class BidirectionalIterator>
void reverse (BidirectionalIterator first, BidirectionalIterator last);
  • BidirectionalIterator：表示一个能够向前和向后遍历的迭代器类型。

参数

  • first：要反转的序列的起始位置。
  • last：要反转的序列的结束位置（不包含在范围内）。

功能

reverse 算法用于将指定范围内的元素顺序完全反转。

示例

以下是使用 reverse 算法反转一个 vector 的示例：

#include <iostream>
#include <vector>
#include <algorithm> // 包含 reverse 函数

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};

    // 使用 reverse 将 vector 反转
    std::reverse(v.begin(), v.end());

    std::cout << "反转后的 vector: ";
    for (int num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果将是反转后的 vector，例如 “反转后的 vector: 5 4 3 2 1”。在这个例子中，reverse 函数将 v 中的元素顺序完全反转。

注意事项

  • reverse 算法会直接修改原始序列，而不是返回新的序列。
  • 序列中的元素顺序完全反转，即第一个元素变成最后一个，最后一个变成第一个，依此类推。
  • 如果 first == last，或者序列中只有一个元素，则不会进行任何操作。

通过 reverse 算法，可以方便地对容器或者数组中的元素顺序进行反转操作，适用于各种需要逆序处理的场景。

这段代码展示了如何使用 C++ 标准库中的 reverse 算法来反转一个 vector 中的元素，并通过自定义的 myPrint 函数对象输出反转前后的结果。

  1. 包含头文件和定义类

    #include <algorithm>  // 包含 reverse 算法
#include <vector>
#include <iostream>   // 包含 cout 和 endl
using namespace std;  // 使用标准命名空间
    • #include <algorithm>：包含了标准库中的 reverse 算法。
    • #include <vector>：包含了使用的容器 vector。
    • #include <iostream>：用于标准输出 cout 和换行 endl。
    • using namespace std;：使用标准库的命名空间，避免每次使用标准库中的元素时都需要加上 std:: 前缀。

  2. 定义类 myPrint

    class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};
    • myPrint 类是一个函数对象，重载了 operator()，用于输出整数值 val，并在每个值后面添加空格。

  3. 定义测试函数 test01()

    void test01()
{
    vector<int> v = {10, 30, 50, 20, 40};

    cout << "反转前： " << endl;
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;

    // 使用 reverse 函数反转 vector v 中的元素
    reverse(v.begin(), v.end());

    cout << "反转后： " << endl;
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;
}

    • 创建了一个 vector 容器 v，并向其中添加了整数元素 {10, 30, 50, 20, 40}。

    • 使用 for_each 算法和自定义的 myPrint 函数对象输出 vector 中的元素，展示了反转前的顺序。

    • 调用 reverse(v.begin(), v.end()) 将 vector v 中的元素顺序完全反转。

    • 再次使用 for_each 和 myPrint 输出反转后的 vector 元素顺序。

  4. 主函数 main()

    int main() {
    test01();
    system("pause");
    return 0;
}
    • 在 main 函数中调用 test01() 来执行上述反转和输出操作。
    • 使用 system("pause") 让程序在控制台暂停，等待用户按任意键结束程序的执行。

总结

这段代码演示了如何使用 C++ 标准库的 reverse 算法来反转 vector 容器中的元素。通过 reverse 函数可以快速、方便地修改容器中元素的顺序，适用于需要倒序处理数据的各种场景。

#include <algorithm>
#include <vector>
class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(20);
	v.push_back(40);
	cout << "反转前： " << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
	cout << "反转后： " << endl;
	reverse(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结

      STL（Standard Template Library）提供了多种排序算法，每种算法都有其特定的优势和适用场景。

一伦明悦
关注
  • 33
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
C++ - SGI 版本 STL源码
10-25
STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了高效且灵活的数据结构和算法。SGI（Silicon Graphics, Inc.）公司在90年代为C++社区贡献了一个广受欢迎的STL实现，因其易...
C++实现oj算法代码-贪心算法.zip
10-28
- 学习并练习使用C++ STL的高级特性，如迭代器、函数对象和模板元编程，以提高代码效率和可读性。 总之，这个压缩包提供了C++实现的oj算法代码，主要关注贪心算法。通过研究这些代码，可以加深对贪心算法的理解，...
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中的一部分，它提供了丰富的容器、迭代器、算法和函数对象等组件，极大地简化了数据结构和算法的实现。余文溪的《C++ STL--数据结构与算法...
C++STL实验报告-迭代器和非变异算法
12-30
在本篇"C++ STL实验报告-迭代器和非变异算法"中，我们将深入探讨C++标准模板库（STL）中的几个核心概念，包括容器、迭代器和非变异算法。实验的目标是熟悉set、multiset、map和multimap这四种关联容器的使用，以及...
c++非变易算法-stl算法
12-31
STL的三大组成部分为容器、迭代器、算法，本文主要讲解STL算法中的非变易算法。本文从实践的角度简单介绍了一下相关函数的使用。C++ STL的非变易算法（Non-mutating algorithms）是一组不破坏函数数据的模板函数，...
Linux C | 管道open打开方式
I_feige的博客
07-12 358
1.
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1076
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++ 生成随机字符串
m0_56306892的博客
07-15 208
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 142
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
05day--C++日期类的实现与取地址运算符的重载
weixin_73863912的博客
07-13 468
• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this。• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动。⽣成的就可以够我们⽤了，不需要去显⽰实现。
C++客户端Qt开发——QT初识
m0_63596031的博客
07-13 837
②中的代码创建，是在堆上new出来的一块空间，当把对象改成在栈上创建，此时就可以看到运行起来的程序无法显示出helloworld，此时label对象随着构造函数的结束，就销毁了，所以应该把它交给对象树进行管理。在QT Designer中创建一个控件的时候，此时会给这个控件分配一个objectName属性，这个属性的值，要求是在界面中是唯一的，不能和别人重复。Qt的对象树模型是一种递归的结构，其中一个对象可以拥有多个子对象，而每个子对象又可以拥有自己的子对象，以此类推。坐标体系：以左上角为原点（0,0），
JNI: 在Kotlin和C++之间通过JNI进行接口传递，两边参数定义映射
tyfwin的博客
07-15 1000
在Kotlin和C++之间通过JNI进行接口传递时，需要注意两边参数定义的映射关系。JNI（Java Native Interface）为Java（Kotlin也适用）与本地语言（如C/C++）之间的交互提供了桥梁。在Kotlin中定义的外部函数和C++中的实现需要通过JNI签名相互对应。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【密钥删除(C/C++)】
m0_70748845的博客
07-12 364
为保证数据安全性，当不需要使用该密钥时，应该删除密钥。
C++中的多态：虚函数与纯虚函数详解
TheJustice_的博客
07-14 428
在C++中，虚函数是在基类中使用virtual关键字声明的函数。当基类指针或引用指向派生类对象时，调用虚函数将执行派生类中的版本。public:public:void display() override { // 使用 override 确保函数被正确重写纯虚函数在基类中使用virtual关键字和= 0来声明。public:// 纯虚函数。
[C/C++入门][变量和运算]7、交换变量（空杯思想）
qq_14840819的专栏
07-14 545
如图，一杯牛奶，一杯咖啡，如何进行交换呢？相信懂的都懂，不懂的看完这个图也就懂了。生活中非常简单的例子，放到我们计算机中也同样适用。
C语言 使用指针的2个小例子
waterHBO的博客
07-14 304
指针这部分，还是要多写多看，反复翻看笔记。
C++ Primer：2.5 处理类型
Linkon的博客
07-13 228
C++ 处理类型
浅谈C嘎嘎类与对象
最新发布
2302_80418176的博客
07-17 409
关键字：class语法格式：class 类名//这里的分号不能少此外，class有三个属性分别是private、public、protected，这三个属性是干啥的，相信大家通过这三个单词的中文意思应该也能知道。那么我们来看一下下面的这个例子。从上面的图片中，我们可以看到整个类分为了两个部分：公共部分和私有部分，私有部分中声明变量，公有部分定义函数以及构造函数等等。
C++静态成员
2402_84626835的博客
07-14 184
对于类中的非静态数据成员，每一个类对象都拥有一个副本，即每个对象的同名数据成员可以分别存储不同的数值，这是保证每个对象拥有区别于其他对象的特征的需要。（1）由于在类的声明中仅仅是对静态数据成员进行了引用声明，因此必须在文件作用域的某个地方对静态数据成员进行定义并进行初始化，即应在类体外对静态数据成员进行初始化（静态数据成员的初始化与它的访问控制权限无关）。静态数据成员的值对每个对象都是一样的，它的值可以被任何一个对象更新，从而实现了同一类的不同对象之间的数据共享。9.1 静态数据成员。
C++编程：STL与高效排序算法解析
在C++编程中，掌握一些实用技巧和标准模板库（STL）的使用能够显著提高编程效率。本讲主要聚焦于C++中的排序算法，它是编程竞赛和日常开发中常见的基础算法。C++标准库提供了便捷的排序功能，主要通过`algorithm`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一伦明悦

感谢，您的支持是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值