c++学习笔记13

最新推荐文章于 2024-07-24 11:32:27 发布
最新推荐文章于 2024-07-24 11:32:27 发布
阅读量72 收藏
点赞数
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41870790/article/details/104107021
版权

STL常用算法

概述：

算法主要由头文件<algorithm><functional><numeric>组成
STL头文件中<algorithm>是最大的一个，范围涉及到比较、交换、查找、遍历操作、复制、修改等等

for_each
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用遍历算法 for_each

//普通函数
void print01(int val) {
	cout << val << " ";
}

//仿函数
class print02 {
public:
	void operator()(int val) {

		cout << val << " ";
	}

};
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;
}
transform

将一个容器搬运到另一个容器中

#include<iostream>
using namespace std;
#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());
	cout << endl;

}

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

找到指定元素，返回指定元素的迭代器，找不到返回结束迭代器end()

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用的查找算法
//find

//查找 内置数据类型
void test01() {
	vector<int > v;
	for (int i = 0; i < 10; i++) {

		v.push_back(i);
	}

	//查找容器中是否有 5 这个元素
	vector<int> ::iterator pos=find(v.begin(), v.end(), 5);
	if (pos == v.end()) {
		cout << "没有找到" << endl;
	}
	else {
		cout << "找到：" << *pos << endl;
	}

}


class Person {
public:
	string m_Name;
	int m_Age;

	Person(string name, int age) {

		this->m_Name = name;
		this->m_Age = age;
	}
	//重载 == 让底层的find知道如何对比Person的数据类型
	bool operator==(const Person &p) {
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age) {
			return true;
		}
		else {
			return false;
		}
	}

};


//查找 自定义数据类型
void test02() {
	vector<Person> v;
	//创建数据
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	vector<Person>::iterator it=find(v.begin(), v.end(), p2);

	if (it == v.end()) {
		cout << "没有找到" << endl;
	}
	else {
		cout << "找到name: " << it->m_Name << " \tage: " << it->m_Age << endl;
	}


}
int main() {
	//test01();
	test02();

	system("pause");
	return 0;
}
find_if

按条件查找元素

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用的查找算法 find_if

//1.查找内置数据类型

//仿函数
class GreaterFive {
public:
	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;
	}
}
//2.查找自定义数据类型
class Person {
public:
	string name;
	int age;

	Person(string name, int age) {

		this->name = name;
		this->age = age;
	}
};

//仿函数
class Func {
public:
	bool operator()(Person& p) {
		return p.age > 20;
	}
};
void test02() {

	vector<Person> v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);	

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	//找年龄大于20的
	vector<Person> :: iterator it=find_if(v.begin(), v.end(), Func());
	if (it == v.end()) {
		cout << "未找到" << endl;
	}
	else {
		cout << "找到: \t姓名：" << it->name << "\t年龄： " << it->age << endl;
	}

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

查找相邻重复元素

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

//查找算法 adjacent_find
void test01() {
	vector<int> v;
	v.push_back(0);
	v.push_back(2);
	v.push_back(0);
	v.push_back(3);
	v.push_back(1);
	v.push_back(4);
	v.push_back(3);
	v.push_back(3);

	vector<int>::iterator it=adjacent_find(v.begin(), v.end());
	if (it == v.end()) {

		cout << "未找到相邻重复元素" << endl;
	}
	else {
		cout << "找到相邻重复元素：" << *it << endl;
	}


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

查找效率很高
查找指定元素是否存在
在无序的序列中不可以使用

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用的查找算法 binary_search
void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);

	}
	//v.push_back(2); //如果是无序的序列结果未知
	//查找容器中是否有9
	//注意：容器必须是有序的序列
	bool ret=binary_search(v.begin(), v.end(), 9);
	if (ret) {
		cout << "找到了" << endl;
	}
	else {
		cout << "没找到" << endl;
	}
}
int main() {

	test01();

	system("pause");

	return 0;
}
count

统计元素个数

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用的查找算法

//1.统计内置数据类型
void test01() {

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

	int num=count(v.begin(), v.end(), 40);

	cout << "40的元素个数为：" << num << endl;
}
//2.统计自定义数据类型
class Person {

public:
	string name;
	int age;
	Person(string name, int age) {
		this->name = name;
		this->age = age;
	}

	bool operator==(const Person& p) {
		if (this->age == p.age) {
			return true;
		}
		else {
			return false;
		}
		
		

	}
};
void test02() {
	vector<Person> v;
	Person p1("刘备", 35);
	Person p2("关羽", 35);
	Person p3("张飞", 35);
	Person p4("赵云", 30);
	Person p5("曹操", 40);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);

	Person p("诸葛亮", 35);

	int num=count(v.begin(), v.end(), p);

	cout << "和诸葛亮同岁数的人员个数为：" << num << endl;

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

按条件统计元素个数

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

//常用查找算法		count_if

//统计内置数据类型

//仿函数 谓词
class Func {
public:
	bool operator()(int val) {
		if (val > 20) {
			return true;
		}
		else {
			return false;
		}
	}
};
void test01() {
	vector<int> v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(30);
	v.push_back(20);
	v.push_back(40);
	v.push_back(20);

	int num=count_if(v.begin(), v.end(), Func());
	cout << "大于20 的数的个数为：" << num << endl;
}

//统计自定义类型
class Person {

public:
	string name;
	int age;
	Person(string name, int age) {

		this->name = name;
		this->age = age;
	}

	//bool operator==(const Person &p) {
	//	if (this->name == p.name && this->age == p.age) {
	//		return true;
	//	}
	//	else {
	//		return false;
	//	}
	//}
};  
//谓词
class Fff {
public:
	bool operator()(const Person & p) {
		if (p.age > 20) {
			return true;
		}
		else {
			return false;
		}

	}
};
void test02() {
	vector<Person> v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);

	count_if(v.begin(), v.end(), Fff());


}

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

常用排序算法

sort
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<functional>

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


//class Greater{
//public:
//	bool operator()(int v1, int v2) {
//		return v1 > v2;
//	}
//
//};
//常用排序算法
void test01() {
	vector<int> v;
	v.push_back(1);
	v.push_back(3);
	v.push_back(5);
	v.push_back(2);
	v.push_back(4);

	//利用 sort进行排序
	sort(v.begin(), v.end());
	for_each(v.begin(), v.end(), func);
	cout << endl;

	//改变为降序
	sort(v.begin(), v.end(), greater<int>());
	for_each(v.begin(), v.end(), func);
	cout << endl;

}
int main() {
	test01();

	system("pause");
	return 0;
}
random_shuffle

洗牌 指定范围内的元素随机调整次序

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<ctime>
void func(int val) {

	cout << val << " ";
}
//洗牌算法 random_shuffle
void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {

		v.push_back(i);
	}
	for_each(v.begin(), v.end(), func);
	cout << endl;
	//利用洗牌算法打乱顺序
	random_shuffle(v.begin(), v.end());

	for_each(v.begin(), v.end(), func);

}
int main() {
	srand((unsigned int)time(NULL));
	test01();
	system("pause");
	return 0;
}
merge

两个容器元素合并 并存储到另一个容器中
注意：两个容器必须是有序的

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
void func(int val) {

	cout << val << endl;
}
//排序算法 merge
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(), func);
}
int main() {
	test01();
	system("pause");
	return 0;
}
reverse

将容器内元素反转

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

void func(int val) {

	cout << val << " ";
}
//常用排序算法 reverse
void test01() {
	vector<int> v;
	v.push_back(1);
	v.push_back(3);
	v.push_back(5);
	v.push_back(2);
	v.push_back(4);

	cout << "反转前:" << endl;

	for_each(v.begin(), v.end(), func);
	cout << endl;

	reverse(v.begin(), v.end());

	for_each(v.begin(), v.end(), func);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}
常用拷贝和替换算法

目标容器要提前开辟空间

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法copy
void fun(int val) {
	cout << val << " ";
}
void test01() {
	vector<int> v1;
	for (int i = 0; i < 10; i++) {

		v1.push_back(i);
	}

	vector<int> v2;
	v2.resize(v1.size());
	copy(v1.begin(), v1.end(), v2.begin());

	for_each(v2.begin(), v2.end(), fun);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}
replace

将容器内指定范围的旧元素改为新元素

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void func(int val) {

	cout << val << " ";
}
//常用拷贝和替换算法 replace
void test01() {
	vector<int > v;
	v.push_back(20);
	v.push_back(30);
	v.push_back(50);
	v.push_back(10);
	v.push_back(40);
	v.push_back(20);
	v.push_back(20);
	v.push_back(20);

	cout << "替换前：" << endl;
	for_each(v.begin(), v.end(), func);
	cout << endl;

	//把所有的20替换为10000
	replace(v.begin(), v.end(), 20, 10000);

	for_each(v.begin(), v.end(), func);
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}
replace_if

将区间内满足条件的元素，替换成指定元素

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

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

class Pred {
public:
	bool operator()(int v) {
		return v > 10;
	}
};
//常用的拷贝和替换算法 replace_if
void test01() {
	vector<int> v;
	v.push_back(10);
	v.push_back(60);
	v.push_back(20);
	v.push_back(80);
	v.push_back(50);
	v.push_back(30);
	v.push_back(40);
	v.push_back(70);

	for_each(v.begin(), v.end(), func);
	cout << endl;

	replace_if(v.begin(), v.end(), Pred(), 1000);//满足Pred的替换为1000

	for_each(v.begin(), v.end(), func);

	cout << endl;

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

互换两个容器的元素

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>



void func(int val) {
	cout << val << " ";
}
//swap
void test01() {
	vector<int> v1,v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 100);

	}
	for_each(v1.begin(), v1.end(), func);
	cout << endl;
	for_each(v2.begin(), v2.end(), func);
	cout << endl;
	cout << "------------------------交换后---------------------------------" << endl;
	swap(v1, v2);
	for_each(v1.begin(), v1.end(), func);
	cout << endl;
	for_each(v2.begin(), v2.end(), func);
	cout << endl;

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

常用算数生成算法

头文件#include<numeric>

accumulate
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<numeric>
void test01() {
	vector<int> v;
	for (int i = 0; i <= 100; i++) {

		v.push_back(i);

	}
	//参数3 是一个起始累加值
	int total = accumulate(v.begin(), v.end(),0);

	cout << "total=" << total << endl;

}

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

向容器中填充指定元素

#include<iostream>
using namespace std;
#include<numeric>
#include<vector>
#include<algorithm>


void func(int val) {

	cout << val << " ";
}
//fill

void test01() {
	vector<int> v;
	v.resize(10);//自动填充0

	//后期重新填充
	fill(v.begin(), v.end(), 100);

	for_each(v.begin(), v.end(), func);
	cout << endl;


}
int main() {
	test01();

	system("pause");
	return 0;
}

常用集合算法

set_intersection

求交集
原来两个容器要有序

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>


void fun(int val) {
	cout << val << " ";
}
//set_intersection   求交集
void test01() {
	vector<int> v1,v2,vTarget;

	for (int i = 0; i < 10; i++) {
		v1.push_back(i);//0~9
		v2.push_back(i + 5);//5~14


	}
	//目标容器需要提前开辟空间
	//最特殊情况为 大容器包含小容器  开辟空间 取小容器的size即可
	vTarget.resize(min(v1.size(),v2.size()));

	//获取交集
	vector<int>::iterator it =set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

	for_each(vTarget.begin(), it, fun);//结束迭代器要用调用set_intersection返回的结束迭代器 因为vTarget.end() 的结束位置是开辟的整个vTarget 而这个大小是一种特殊情况


}

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

求并集

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>


void func(int val) {

	cout << val << " ";
}
//set_union
void test01() {
	vector<int> v1,v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}

	vector<int> vTarget;
	vTarget.resize(v1.size() + v2.size());

	vector<int>::iterator it=set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());//返回值是最后一个元素的位置

	for_each(vTarget.begin(), it, func);
	
}

int main() {
	test01();


	system("pause");
	return 0;
}
set_difference

求差集

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

void func(int val) {
	cout << val << " ";
}
//set_difference
void test01() {
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}

	vector<int> vTarget;
	vTarget.resize(max(v1.size(), v2.size()));

	cout << "v1和v2的差集为：" << endl;

	vector<int>::iterator it=set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), it, func);
	cout << endl;


}
int main() {
	test01();

	system("pause");
	return 0;
}
落落落Luo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员C++学习笔记
weixin_46015291的博客
05-31 4835
C++基础入门 1 C++初识 1.1 第一个C++程序 编写一个C++程序总共分为4个步骤 创建项目 创建文件 编写代码 运行程序 1.1.1 创建项目 ​ Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开 1.1.2 创建文件 右键源文件，选择添加->新建项 给C++文件起个名称，然后点击添加即可。 1.1.3 编写代码 #include<iostream> using namespace std; int main() { cout &
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
C++学习笔记
ftm_csdn的博客
04-16 1万+
C++是C语言的超集。
c++学习笔记
Tinelines的博客
03-16 1105
1.namespace 命名空间 1.1命名空间的三种声明方式 using namespace; using namespace::func1; namespace::func1();
z3 C++学习笔记
T_T233333333的博客
03-06 3352
因为项目需要使用z3库来解决问题，所以自己学习了一下，结果发现网上教程比较少，而且大部分都是使用Python，而我本人是C++的忠实信徒，在知道C++也可以使用z3库以后我毫不犹豫地着手用C++使用z3，但是我很快发现，网上基本没有关于C++使用z3的教程（中文社区一点都没有），因此我记录一下我自己的学习过程希望能够帮助到其他学习的人。 教程链接 网上现有的有三个教程： 官方example.cpp文档：https://github.com/Z3Prover/z3/blob/master/examples.
明解C++学习笔记
Tanuki的博客
05-05 1397
这本书非常适合初学者学习
UE C++学习笔记
weixin_44212242的博客
05-16 3304
UE C++入门级程序编制笔记，基础中的基础，了解UE C++的书写规范和一般要求，实现蓝图，C++混合开发。
C++学习笔记（二十四）：c++ this
qq_16701727的博客
01-05 1056
【代码】C++学习笔记（二十四）：c++ this。
c++学习笔记1.1引用
Spalanzani的博客
03-16 1076
c++学习笔记1.1引用c++学习笔记1.1引用引用的概念：引用的声明：参考示例1：指针的引用 c++学习笔记1.1引用 引用的概念： 引用就是某一变量（目标）的一个别名，对引用操作与对变量直接操作完全一样。通俗来说就是该变量的一个外号，称呼不同其他完全一样。 引用的声明： 引用的声明方法如下： 类型标识符 &引用名=目标变量名; 假如有一个变量a，想要给他起一个外号b，我们可以这样声明: int a; //定义一个整型变量a int &b=a; //生命b是a的引用 上面语句声明了b是
C++详细学习笔记（一）
热门推荐
好学的小李的博客
06-09 1万+
首先，本次学习主要参考的书籍是C++Primer Plus第六版，为了方便今后参阅，故写下该学习笔记。 C++是在C语言基础上开发的一种集面向对象编程、泛型编程和过程化编程于一体的编程语言，是C语言的超集。 一、预备知识 C++有三件法宝：1、继承了C语言高效、简洁、快速和可移植性的传统（C代表的过程性编程）；2、面向对象的特性带来了全新的编程方法，这种方法是为了应付复杂程......
【C++学习笔记】头文件详解
weixin_45695709的博客
05-03 3742
个人整理学习用，非教材，有错误欢迎指正 目录头文件成员变量参数本地变量 头文件   究竟什么是头文件？   首先说明一个概念，所谓的文件后缀并不是必须的，在Linux下这种特点尤为明显。对于编译器来说，无论是.c文件 .cpp文件，抑或是.h文件，都是同一种文件形式，区别仅仅是你去执行该文件的方式。 上图是在Linux环境中编译一个.cpp文件 当使用 g++编译器时，a.cpp被视为一个CPP文件，可以正常编译，编译后的文件也能被正常运行。但使用gcc编译器编译时，gcc会把a.cpp视为一个C文件，
C++学习笔记.pdf
08-12
C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
c++学习笔记精华版
08-27
### C++ 学习笔记精华版 #### 一、C++ 语言概述 **1、历史背景** - **C++ 的江湖地位** - Java、C、C++、Python、C# 是当前主流的编程语言之一，而 C++ 在这些语言中以其高效性和灵活性著称。 - **C++ 之父 ...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1183
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
VS2019编译和使用gtest测试（C++）
最新发布
m0_65635427的博客
07-24 266
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1126
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
C++ | Leetcode C++题解之第275题H指数II
Ddddddd_158的博客
07-23 366
C++ | Leetcode C++题解之第275题H指数II
C++学习笔记：面向过程与C++概述
"这篇文档是关于C++的学习笔记，主要关注面向过程的编程思想，并提到了C++的一些基本概念和历史。文档指出C++是由比雅尼·斯特劳斯特鲁普博士开发的一种通用编程语言，它在C语言的基础上增加了面向对象、数据抽象和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值