【基础】【三】【STL】C++学习日记

最新推荐文章于 2024-07-10 22:49:54 发布
最新推荐文章于 2024-07-10 22:49:54 发布
阅读量322 收藏
点赞数
分类专栏： c++学习日记 文章标签： c++ 基础 STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35654659/article/details/106750734
版权

C++学习日记

Day 11

STL(标准模板库)

广义分类：容器，算法，迭代器
容器和算法之间通过迭代器进行无缝连接
STL六大组件：容器，算法，迭代器，仿函数，适配器(配接器)、空间配置器
1、容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据
2、算法：各种常用的算法：如sort、find、copy、for_each等
3、迭代器：扮演了容器和算法的胶合剂
4、仿函数：行为类似函数，可作为算法的某种策略
5、适配器：一种用来修饰容器或者仿函数或迭代器接口的东西
6、空间配置器：负责空间的配置与管理

STL中容器、算法、迭代器

容器分为：序列式容器和关联式容器：
       序列式容器：强调值的排序，序列式容器中的每个元素均有固定的位置
       关联式容器：二叉树结构，各元素间没有严格的物理上的顺序关系
算法分为：质变算法和非质变算法：
       质变算法：指运算过程中会更改区间内的元素的内容，例如拷贝、替换、删除等
       非质变算法：指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等
迭代器：提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式，每个容器都有自己专属的迭代器。迭代器使用非常类似于指针
迭代器种类：

种类功能支持运算
输入迭代器对数据的只读方向只读，支持++、==、!=
输出迭代器对数据的只写访问只写，支持++
前向迭代器读写操作，并能向前推进迭代器读写，支持++、==、!=
双向迭代器读写操作，并能向前和向后操作读写，支持++、–
随机访问迭代器读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器读写，支持++、–、[n]、-n、<、<=、>、>=

常用的容器中迭代器种类为双向迭代器和随机访问迭代器

容器初识(vector)

存放内置的数据类型
#include<iostream>
using namespace std;
#include<vector>
#include <algorithm>
void print(int val)
{
	cout << val << endl;
}
int main()
{
	vector<int>arr;
	// 从尾部插入数据
	arr.push_back(10);
	arr.push_back(20);
	arr.push_back(30);
	// 起始迭代器，指向容器的第一个元素
	vector<int>::iterator itBegin = arr.begin();
	// 结束迭代器，指向容器中最后一个 元素的下一个位置
	vector<int>::iterator itEnd = arr.end();

	// 1、遍历
	while (itBegin != itEnd)
	{
		cout << *itBegin << endl;
		itBegin++;
	}
	// 2、遍历
	for (vector<int>::iterator i = arr.begin(); i != arr.end(); i++)
	{
		cout << *i << endl;
	}
	// 3、STL内部遍历方法，需要#include <algorithm>
	// 回调技术，一开始不调用，在遍历的期间调用
	for_each(arr.begin(), arr.end(), print);
	return 0;
}
存放自定义数据类型
#include<iostream>
using namespace std;
#include<vector>
#include<string>
class Person
{
public:
	Person(string name, int age)
	{
		m_Name = name;
		m_Age = age;
	}
	string m_Name;
	int m_Age;
};
void test01()
{
	vector<Person> arr;
	arr.push_back(Person("张三", 18));
	arr.push_back(Person("李四", 28));
	for (vector<Person>::iterator i = arr.begin(); i != arr.end(); i++)
	{
		cout << "姓名为:" << i->m_Name << "  年龄为：" << i->m_Age << endl;
		cout << "姓名为:" << (*i).m_Name << "  年龄为：" << (*i).m_Age << endl;

	}
}
void test02()
{
	vector<Person*> arr;
	arr.push_back(&Person("张三", 18));
	arr.push_back(&Person("李四", 28));
	for (vector<Person*>::iterator i = arr.begin(); i != arr.end(); i++)
	{
		cout << "姓名为:" << (*i)->m_Name << "  年龄为：" << (*i)->m_Age << endl;

	}
}
int main()
{
	test01();
	test02();
	return 0;
}
容器嵌套容器
#include<iostream>
using namespace std;
#include<vector>
void test()
{
	vector<vector<int>> arr;
	vector<int>a1;
	vector<int>a2;
	vector<int>a3;
	vector<int>a4;
	for (int i = 0; i < 4; i++)
	{
		a1.push_back(i + 1);
		a2.push_back(i + 5);
		a3.push_back(i + 9);
		a4.push_back(i + 13);
	}
	arr.push_back(a1);
	arr.push_back(a2);
	arr.push_back(a3);
	arr.push_back(a4);

	for (vector<vector<int>>::iterator i = arr.begin(); i != arr.end(); i++)
	{
		for (vector<int>::iterator j = (*i).begin(); j != (*i).end(); j++)
		{
			cout << *j << " ";
		}
		cout << endl;
	}
}
int main()
{
	test();
	return 0;
}

string容器

本质：string本质是类
string和char*区别：
    1、char是一个指针
    2、string是一个类，类内封装了char，管理这个字符串，是一个char型的容器
特点：
   内部封装了很多成员方法，例如查找find，拷贝copy，删除delete，替换replace，插入insert，string管理char所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责

构造函数

构造函数：

string();                    // 创建一个空的字符串
string(const char *s);       // 使用字符串s初始化
string(const string &str);   // 使用string对象初始化另一个string对象
string(int n, char c);       // 使用n个字符c初始化
赋值操作

赋值函数：

string& operator=(const char *s);    // char*字符串赋值给当前字符串
string& operator=(const string &s);  // 字符串s赋值给当前字符串
string& operator=(char c);           // 字符c赋值给当前字符串
string& assign(const char *s);       // 字符串s赋值给当前字符串
string& assign(const char *s, int n);// 字符串s的前n个字符赋值给当前字符串
string& assign(const string &s);     // 字符串s赋值给当前字符串
string& assign(int n, char c);       // n个字符c赋给当前字符串
拼接操作

拼接函数：

string& operator+=(const char* str);   // 重载+=运算符
string& operator+=(const char c);      // 重载+=运算符
string& operator+=(const string& str);  // 重载+=运算符
string& append(const char *s);         // 把字符串s连接到当前字符串结尾
string& append(const char *s, int n);  // 把字符串s的前n个字符串连接到当前字符串结尾
string& append(const string *s);       // 同operator+=(const string& str)
string& append(const string &s， int pos, int n); // 字符串中从pos开始的n个字符连接到字符串结尾
查找和替换

查找和替换函数：

int find(const string& str, int pos = 0) const;  // 查找str第一次出现的位置，从pos开始查找
int find(const char* s, int pos = 0) const;      // 查找s第一次出现位置，从pos开始查找
int find(const char* s, int pos, int n) const;   // 从pos位置查找s的前n个字符第一次出现的位置
int find(const char c, int pos = 0) const;      // 查找字符c第一次出现位置
int rfind(const string& str, int pos = npos) const; // 查找str最后一次出现的位置，从pos开始查找
int rfind(const char* s, int pos = npos) const;  // 查找s最后一次出现位置，从pos开始查找
int rfind(const char* s, int pos, int n) const;  // 从pos位置查找s的前n个字符最后一次出现的位置
int rfind(const char c, int pos = 0) const;  // 查找字符c最后一次出现位置
string& replace(int pos, int n, const string &str); // 替换从pos开始的n个字符为字符串str
string& replace(int pos, int n, const char* s); // 替换从pos开始的n个字符为字符串s

find从左向右查找，rfind从右向左查找，找不到返回-1

比较

按照ASCII码进行比较
= 返回 0
> 返回 1
< 返回 -1
函数原型：

int compare(const string &s) const;  //与字符串s比较
int compare(const char *s) const;    // 与字符串s比较
字符存取

函数原型：

char& operator[](int n);  // 通过[]方式取字符
char& at(int n);          // 通过at方法取字符
插入和删除

函数原型：

string& insert(int pos, const char* s);   // 在指定位置插入字符串
string& insert(int pos, const string& s); // 在指定位置插入字符串
string& insert(int pos, int n, char c);   // 在指定位置插入n个字符c
string& erase(int pos, int n = npos);     // 删除从pos开始的n个字符

插入和删除起始下标从0开始

子串

函数原型

string substr(int pos = 0, int n = npos) const; // 返回由pos开始的n个字符组成的字符串

vector容器

vector也称为单端数组
vector与普通数组的区别：数组是静态空间，vector可以动态扩展
动态扩展：不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间
vector容器的迭代器是支持随机访问的迭代器

构造函数

函数原型：

vector<T> v;               // 采用模板实现类实现，默认构造函数
vector(v.begin(), v.end()); // 将v区间内的元素拷贝给本身
vector(n, elem);            // 构造函数将n个elem拷贝给本身
vector(const vector &vec);  // 构造拷贝函数
赋制操作

函数原型：

vector& operator=(const vector &vec); // 重载等号操作符
assign(beg, end);  // 将[beg, end)区间中的数据拷贝赋值给本身
assign(n, elem);  // 将n个elem拷贝复制给本身
容量和大小

函数原型：

empty();              // 判断容器是否为空
capacity();           // 容器的容量
size();               // 容器元素的个数
resize(int num);      // 重新指定容器的长度为num，若容器变长，则以默认值填充新位置，若容器变短，则末尾超出容器长度的元素被删除
resize(int num, elem);  // 重新指定容器的长度为num，若容器变长，则以elem填充新位置，若容器变短，则末尾超出容器长度的元素被删除
插入和删除

函数原型：

push_back(ele);                             // 尾部插入ele
pop_back();                                 // 删除最后一个元素
insert(const_iterator pos, ele);            // 迭代器指向位置pos插入元素ele
insert(const_iterator pos, int count, ele); // 迭代器指向位置pos插入count个元素ele
erase(const_iterator pos);                 // 删除迭代器指向的元素
erase(const_iterator start, const_iterator end);  // 删除迭代器从start到end之间的元素
clear();                                // 删除容器中所有元素
数据存取

函数原型：

at(int idx);             // 返回索引idx所指的数据
operator[](int idx);     // 返回索引idx所指的数据
front();                 // 返回容器中的第一个元素
back();                  // 返回容器中最后一个元素
互换容器

实现两个容器内元素进行交换
函数原型：

swap(vec);  // 将vec与本身的元素互换

作用：收缩内存，例：

#include<iostream>
using namespace std;
#include<vector>
int main()
{
	vector<int> a;
	for (int i = 0; i < 10000; i++)
	{
		a.push_back(i);
	}
	cout << "a的容量为：" << a.capacity() << endl;
	cout << "a的长度为：" << a.size() << endl;
	a.resize(3);
	cout << "a进行resize后" << endl;
	cout << "a的容量为：" << a.capacity() << endl;
	cout << "a的长度为：" << a.size() << endl;

	vector<int>(a).swap(a);
	cout << "a进行swap收缩容量后" << endl;
	cout << "a的容量为：" << a.capacity() << endl;
	cout << "a的长度为：" << a.size() << endl;
	return 0;
}

原理：

vector<int>(a).swap(a);
// 为匿名函数，按a进行初始化
vector<int>(a)
// 匿名对象再和a进行swap操作
vector<int>(a).swap(a)
// 匿名对象代码执行完后，系统帮忙回收空间
预留空间

减少vector在动态扩展容量时的扩展次数
函数原型：

reserve(int len); // 容器预留len个元素长度，预留位置不初始化，元素不可访问

例如：

#include<iostream>
using namespace std;
#include<vector>
int main()
{
	vector<int> a;
	// 预留空间
	a.reserve(10000);
	int num = 0;
	int* p = NULL;
	for (int i = 0; i < 10000; i++)
	{
		a.push_back(i);
		if (p != &a[0])
		{
			p = &a[0];
			num++;
		}
	}
	// 预留空间下num = 1
	// 未预留空间下num = 24，因为每次增加时超过容量就会重新构造拷贝一个vector
	cout << "num = " << num << endl;
	return 0;
}

deque容器

双端数组，可以对头端进行插入删除操作
deque与vector区别：
    1、vector对于头部的插入删除效率低，数据量越大，效率越低
    2、deque相对而言，对头部的插入删除速度会比vector快
    3、vector访问元素时的速度会比deque快，这和两者的内部实现有关
内部原理：
    1、内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
    2、中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间

构造函数

函数原型：

deque<T> deqT;               // 采用模板实现类实现，默认构造函数
deque(deqT.begin(), deqT.end()); // 将deqT区间内的元素拷贝给本身
deque(n, elem);            // 构造函数将n个elem拷贝给本身
deque(const deque &deqT);  // 构造拷贝函数
赋值操作

函数原型：

deque& operator=(const deque &deq); // 重载等号操作符
assign(beg, end);  // 将[beg, end)区间中的数据拷贝赋值给本身
assign(n, elem);  // 将n个elem拷贝复制给本身
大小操作

函数原型：

empty();              // 判断容器是否为空
size();               // 容器元素的个数
resize(int num);      // 重新指定容器的长度为num，若容器变长，则以默认值填充新位置，若容器变短，则末尾超出容器长度的元素被删除
resize(int num, elem);  // 重新指定容器的长度为num，若容器变长，则以elem填充新位置，若容器变短，则末尾超出容器长度的元素被删除

deque没有容量的概念

插入和删除

函数原型：

push_back(ele);          // 尾部插入ele
push_front(ele);         // 头部插入ele
pop_back();              // 删除最后一个元素
pop_front();             // 删除第一个元素
insert(pos, ele);        // 在迭代器位置pos插入元素ele的拷贝，返回新数据的位置
insert(pos, count, ele); // 在迭代器位置pos插入count个元素ele，无返回值
insert(pos, beg, end);  // 在迭代器位置pos插入区间内的元素，无返回值
erase(pos);             // 删除迭代器pos位置的元素，返回下一个元素的位置
erase(beg, end);       // 删除区间从neg到end之间的元素，返回下一个元素的位置
clear();               // 删除容器中所有元素
数据存取

函数原型：

at(int idx);             // 返回索引idx所指的数据
operator[](int idx);     // 返回索引idx所指的数据
front();                 // 返回容器中的第一个元素
back();                  // 返回容器中最后一个元素
排序

利用算法实现对deque容器排序
算法：

sort(iterator beg, iterator end);  // 对区间内进行排序

对于任何支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序

stack容器

先进后出，只有一个出口
栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为

构造函数

函数原型：

stack<T> stk;               // 采用模板实现类实现，默认构造函数
stack(const stack &stk);  // 构造拷贝函数
赋值操作

函数原型：

stack& operator=(const stack &stk); // 重载等号操作符
数据存取

函数原型：

push(int elem);            // 向栈顶添加元素
pop();                    // 从栈顶移除第一个元素
top();                    // 返回栈顶元素
大小操作

函数原型：

empty();                   // 判断栈是否为空
size();                    // 返回栈的大小

queue容器

先进先出，有两个出口
一端新增元素，一端移除元素
只有队头和队尾能被外界使用，因此队列不允许有便利行为

构造函数

函数原型：

queue<T> que;               // 采用模板实现类实现，默认构造函数
queue(const queue& que);   // 构造拷贝函数
赋值操作

函数原型：

queue& operator=(const queue& que); // 重载等号操作符
数据存取

函数原型：

push(int elem);          // 向队尾添加元素
pop();                   // 从队头移除第一个元素
back();                  // 返回最后一个元素
front();                 // 返回第一个元素
大小操作

函数原型：

empty();                   // 判断是否为空
size();                    // 返回栈的大小

list容器

将数据进行链式存储
链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的
链表组成：结点
结点组成：指针域和数据域
STL中的链表是一个双向循环链表
因为链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器
优点：
    1、采用动态存储分配，不会造成内存浪费和溢出
    2、链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
缺点：空间(指针域)和时间(遍历)额外耗费较大
list有一个重要性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vetor是不成立的

构造函数

函数原型：

list<T> lst;                 // 采用模板实现类实现，默认构造函数
list(lst.begin(), lst.end()); // 将lst区间内的元素拷贝给本身
list(n, elem);            // 构造函数将n个elem拷贝给本身
list(const list &lst);     // 构造拷贝函数
赋值和交换

函数原型：

list& operator=(const list &lst); // 重载等号操作符
assign(beg, end);  // 将[beg, end)区间中的数据拷贝赋值给本身
assign(n, elem);  // 将n个elem拷贝复制给本身
swap(list);       //将list与本身的元素互换
大小操作

函数原型：

empty();              // 判断容器是否为空
size();               // 容器元素的个数
resize(int num);      // 重新指定容器的长度为num，若容器变长，则以默认值填充新位置，若容器变短，则末尾超出容器长度的元素被删除
resize(int num, elem);  // 重新指定容器的长度为num，若容器变长，则以elem填充新位置，若容器变短，则末尾超出容器长度的元素被删除
插入和删除

函数原型：

push_back(ele);          // 尾部插入ele
push_front(ele);         // 头部插入ele
pop_back();              // 删除最后一个元素
pop_front();             // 删除第一个元素
insert(pos, ele);        // 在迭代器位置pos插入元素ele的拷贝，返回新数据的位置
insert(pos, count, ele); // 在迭代器位置pos插入count个元素ele，无返回值
insert(pos, beg, end);  // 在迭代器位置pos插入区间内的元素，无返回值
erase(pos);             // 删除迭代器pos位置的元素，返回下一个元素的位置
erase(beg, end);       // 删除区间从neg到end之间的元素，返回下一个元素的位置
clear();               // 删除容器中所有元素
remove(elem);          // 删除容器中所有与elem值匹配的元素
数据存取

函数原型：

front();                 // 返回容器中的第一个元素
back();                  // 返回容器中最后一个元素
反转和排序

函数原型：

reverse();  // 反转链表
sort();     // 链表排序，默认排序规则，升序
sort(compare);  // 自定义规则排序，compare函数定义排序规则

对于任何不支持支持随机访问的迭代器的容器，都不可以用标准算法
内部(成员函数)会提供对应的一些算法

set/multiset容器

所用元素都会在插入时自动被排序
本质：set/multiset属于关联式容器，底层结构是用二叉树实现

构造函数

函数原型：

set<T> st;              // 采用模板实现类实现，默认构造函数
set(const set &st);     // 构造拷贝函数
赋值和交换

函数原型：

set& operator=(const set &st); // 重载等号操作符
swap(set);                     //将set与本身的元素互换
大小操作

函数原型：

empty();              // 判断容器是否为空
size();               // 容器元素的个数
插入和删除

函数原型：

insert(elem);   	    // 容器中插入元素
erase(pos);             // 删除迭代器pos位置的元素，返回下一个元素的位置
erase(beg, end);        // 删除区间从neg到end之间的元素，返回下一个元素的位置
clear();                // 删除容器中所有元素
erase(elem);            // 删除容器中elem的元素
查找和统计

对set容器进行查找数据以及统计数据
函数原型：

find(key);   // 查找key是否存在，若存在，返回该键的元素的迭代器，若不存在，返回set.end()
count(key);  // 统计key的元素个数
set和multiset区别

set和multiset区别：
     1、sel不允许容器中有重复的元素
     2、multiset允许容器中有重复的元素
     3、set插入数据的同时会返回插入结果(组：迭代器和bool值)，表示插入是否成功
     4、multiset不会检测数据，因此可以插入重复数据

#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s;
	pair<set<int>::iterator, bool> ret = s.insert(10);
	if (ret.second)
	{
		cout << "10插入成功" << endl;
	}
	else
	{
		cout << "10插入失败" << endl;
	}
	ret = s.insert(10);
	if (ret.second)
	{
		cout << "10插入成功" << endl;
	}
	else
	{
		cout << "10插入失败" << endl;
	}
	return 0;
}
pair对组创建

成对出现的数据，利用对组可以返回两个数据
创建方式：

pair<type, type> p(value1, value2);
pair<type, type> p = make_pair(value1, value2);
排序

默认排序从小到大，利用仿函数改变排序规则，要在插入前改变排序规则

#include<iostream>
using namespace std;
#include<set>
class Compare
{
public:
	bool operator()(int v1, int v2) const
	{
		return v1 > v2;
	}
};
int main()
{
	set<int, Compare> s;
	s.insert(10);
	s.insert(40);
	s.insert(30);
	s.insert(20);
	s.insert(50);
	s.insert(90);
	for (set<int, Compare>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	return 0;
}

map/multimap容器

map中所有元素都是pair(对组)
pair中第一个元素为key(键值)，起到索引作用，第二个元素为value(实值)
所有元素都会根据元素的键值自动排序
本质：map/multimap属于关联式容器，底层结构是用二叉树实现
优点：可以根据key值快速找到value值

构造函数

函数原型：

map<T1, T2> mp;              // 采用模板实现类实现，默认构造函数
map(const map &mp);     // 构造拷贝函数
赋值和交换

函数原型：

map& operator=(const map &mp); // 重载等号操作符
swap(mp);                     //将mp与本身的元素互换
大小操作

函数原型：

empty();              // 判断容器是否为空
size();               // 容器元素的个数
插入和删除

函数原型：

insert(elem);   	    // 容器中插入元素
erase(pos);             // 删除迭代器pos位置的元素，返回下一个元素的位置
erase(beg, end);        // 删除区间从neg到end之间的元素，返回下一个元素的位置
clear();                // 删除容器中所有元素
erase(key);             // 删除容器中键值为key的元素

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

int main()
{
	map<int, int>m;
	// 第一种插入
	m.insert(pair<int, int>(1, 20));
	// 第二种插入
	m.insert(make_pair(2, 20));
	// 第三种插入
	m.insert(map<int, int>::value_type(3, 30));
	// 第四种插入，不建议使用，没有键值的数，就会自动添加一个键值，对应的值为0
	// 用来取值
	m[4] = 40;
	return 0;
}
查找和统计

对map容器进行查找数据以及统计数据
函数原型：

find(key);   // 查找key是否存在，若存在，返回该键的元素的迭代器，若不存在，返回map.end()
count(key);  // 统计key的元素个数
map/multimap区别

map/multimap区别：
    1、map不允许容器中有重复key值元素
    2、multimap允许容器中有重复key值元素

排序

默认排序按照key值从小到大，利用仿函数改变排序规则，要在插入前改变排序规则

#include<iostream>
using namespace std;
#include<map>
class Compare
{
public:
	bool operator()(int v1, int v2) const
	{
		return v1 > v2;
	}
};
int main()
{
	map<int, int, Compare> m;
	m.insert(make_pair(5, 20));
	m.insert(make_pair(2, 10));
	m.insert(make_pair(3, 0));
	m.insert(make_pair(7, 50));
	m.insert(make_pair(8, 15));
	m.insert(make_pair(9, 25));
	for (map<int, int, Compare>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << (*it).first << " " << (*it).second << " ";
	}
	return 0;
}
allin_it
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[C++高级部分] 泛型编程和STL技术 黑马课程学习笔记
a123456_9的博客
07-04 149
C++的另一种编程思想称为泛型编程，主要利用的技术就是模板；C++提供两种模板机制：函数模板和类模板建立一个通用函数，其函数返回值类型与形参类型不具体制定，而是用一个虚拟的类型来代表 使用函数模板：①自动类型推导 直接像调用函数一样，传入实参即可，编译器自动推导出实参的类型 ②显示指定类型 函数名传入实参值基本语法和函数模板差不多，无非就是模板参数列表中多加了几个模板类型 调用时：Person p1 (“孙悟空”， 999)；...
[学习笔记]c++基础-day01
x_0711的博客
08-05 140
目录 1、面向对象程序设计： 1.1概述：对象、类、消息传递、方法 1.2基本特征： 1.3语言:c#、java、c++ 2、c++基本语法 2.1编写一个hello world程序 2.2单行注释和多行注释 2.3变量（c++中所有数据都存放在内存中） 2.4常量：用于记录程序中不可更改的数据 2.5关键字： 2.6标识符命名规则 3、数据类型 3.1整型： 3.2浮点型（表示小数） 3.3转义字符: 3.4字符型：单个字符 ’’，只占用一个字符 3.5字符串型：一串字符
vector容器（单端数组）
m0_64837135的博客
03-25 693
1、vector容器基本概念。 1）功能。 vector容器数据结构与数组非常相似，也称为单端数组。 2）vector与普通数组区别？ 普通数组 --> 静态空间 vector容器 --> 动态扩展 3）动态扩展。 并不是在原空间之后继续接新空间，而是找更大的内存空间，然后原数据拷贝到新空间上，释放原空间。 4）迭代器。 vector容器迭代器就是支持随机访问的迭代器。 5)头文件 #include <vector> string类包含在#include <i...
C++STL10_STL基本概念,STL三大组件,string容器,vector容器（单端数组）,deque容器（双端数组）
weixin_41865866的博客
09-25 430
STL基本概念,STL三大组件,string容器,vector容器（单端数组）,deque容器（双端数组）
185-263 STL
little__rookie的博客
03-10 690
基本概念： 容器被分为： 序列式容器：每个元素均有固定位置 关联式容器：各元素之间没有严格意义上的物理关系，如二叉树 算法被分为： 质变算法、非质变算法 区别在于运算过程是否会改变区间内元素的内容 迭代器： 提供一种方法，能够依序访问某个容器的各个元素，而无需暴露该容器的内部表示方式。 每个容器都是有自己专属的迭代器 迭代器用法类似指针 迭代器分类： vector: ...
C++提高编程（2.2）—— vector容器
weixin_45418001的博客
05-28 646
3.2 vector容器 3.2.1 vector基本概念 功能： vector数据结构和数组非常相似，也称为单端数组 vector与普通数组区别： 不同之处在于数组是静态空间，而vector可以动态扩展 动态扩展： 并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间 vector容器的迭代器是支持随机访问的迭代器 3.2.2 vector构造函数 功能描述： 创建vector容器 函数原型： vector<T> v;
【C++学习笔记】
m0_66706847的博客
07-29 339
C++学习笔记
C++STL学习笔记.pdf
05-23
关于学习C++《STL模板库》以及学习《STL源码剖析》的学习笔记。
c++基础STL入门ppt课件.ppt
11-13
C++基础STL入门ppt课件 这份PPT课件主要讲解C++基础知识，特别是STL（Standard Template Library）的概念和组成。下面是从这份课件中提炼出的重要知识点： 1. 抽象的重要性：抽象是计算机科学的重要进步，许多都是...
c++ SGI STL源代码学习
06-04
SGI STL，全称为Stanford Graphics Group Standard Template ...总之，学习SGI STL源代码是C++进阶道路上必不可少的一步，能够让我们深入理解C++的标准库，提高编程效率，使我们能编写出更加优雅、高效的C++代码。
C++STL的学习资料与笔记
04-26
这里荔枝总结了一下下自己在学习C++的STL库的时候自己的一份学习笔记，这也是荔枝第一次上传资源到CSDN哈哈哈哈哈哈，如果有需要的话大家可以自行下载哈，希望能够帮助到大家。最后大家注意这里面的只是基础的东西，...
STL基础教程C++.docm
08-22
c++_STL 入门基础 笔记，包含一些生动的例子 和 讲解，希望这个讲解可以帮到更多的想要学好编程的人
vector 容器也称为单端数组
weixin_62688604的博客
04-20 90
//vector 容器也称为单端数组，可以动态扩展 //动态扩展：找更大的内存空间，拷贝原数据，释放源空间 //迭代器支持随机访问，可以+3，+4 //front()访问容器中第一个元素，back()访问最后一个元素 //迭代器begin()指向第一个元素，end（）指向最后一个元素的下一个 //迭代器rend()指向第一个元素的前一个，rbegin()指向最后一个元素 //push_back尾插，insert（）插入，erase()删除 //三种赋值操作 ，重载等号，assign函数 //四种构...
C++学习记录
YXXXYX的博客
05-30 463
封装 C++和C语言最大的不同就是面向对象编程思想，而封装就是面向对象编程很重要的一部分； C++讲究万物皆可对象，对象到底是什么？和类又有什么关系呢？ 举个例子：人类就涵盖了世界上各种各样不同的人，所以人类就是一个类，这个类的属性可以有身高、体重、年龄、肤色、性别等等，他们都可能会走路、做饭、睡觉等行为；而每一个人都是这个类的对象；类就是将一个对象的属性和行为的综合； C++用class定义一个类，类中有三部分： 1、属性 2、行为 3、访问权限(public,protected,private) 语法：
vector容器
kube_const的博客
04-21 181
#vector基本概念 vector和数据很类似，又被称为单端数组 但有区别，vector可以动态拓展 动态拓展含义 动态数组并不是在原空间之后续接新空间，而是找更大的新的内存空间，然后将原数组拷贝到新的空间，释放原空间 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-19Y3QoJ5-1587438558726)( https://i.loli.net/2020/...
C++STL总结
weixin_56493138的博客
10-07 142
STL总结容器string：字符串vector： 单端数组（向量）deque：双端数组stack：栈, queue：队列list：链表set：集合pair：对组, map：键值对内建函数对象算法遍历算法查找算法排序算法拷贝和替换算法集合算法算术生成算法 容器 string：字符串 C++STL总结——string：字符串 vector： 单端数组（向量） C++STL总结——vector：单端数组（向量） deque：双端数组 C++STL总结——deque：双端数组 stack：栈, queue：队列 C
C++STL总结——vector：单端数组（向量）
weixin_56493138的博客
10-07 249
C++STL总结——vector：单端数组（向量）整合迭代器打印构造赋值容量和大小插入和删除数据的存取互换容器预留空间 包含头文件：vector 整合 //vector：单端数组 void PrintVector(vector<int>& v) { //利用迭代器打印vector容器 for (vector<int>:: iterator it = v.begin(); it != v.end(); it++) { cout << *it <<
C++ 多态
最新发布
wxk2227814847的博客
07-10 501
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
Standard Template Library指南 doc
04-07
本文是关于标准模板库（Standard Template Library，STL）的学习指南，主要内容包括STL的介绍、C++基础知识、STL的概述以及学习STL的方法。 在本文中，我们将学习如何有效地使用STL提供的各种数据结构和算法，以便...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值