C++标准库STL部分代码学习，2024大厂Java面试真题集锦

// 本实作中默认构造出的vector不分配内存空间

vector() : start(0), finish(0), end_of_storage(0) {}

vector(size_type n, const T& value) { fill_initialize(n, value); }

vector(int n, const T& value) { fill_initialize(n, value); }

vector(long n, const T& value) { fill_initialize(n, value); }

// 需要对象提供默认构造函数

explicit vector(size_type n) { fill_initialize(n, T()); }

vector(const vector<T, Alloc>& x)

{

start = allocate_and_copy(x.end() - x.begin(), x.begin(), x.end());

finish = start + (x.end() - x.begin());

end_of_storage = finish;

}

//没有纯虚析构函数哦

~vector()

{

// 析构对象

destroy(start, finish);

// 释放内存

deallocate();

}

vector<T, Alloc>& operator=(const vector<T, Alloc>& x);

// 提供访问函数

reference front() { return *begin(); }

reference back() { return *(end() - 1); }

// 向容器尾追加一个元素, 可能导致内存重新分配

// push_back(const T& x)

// |

// |---------------- 容量已满?

// |

// ----------------------------

// No | | Yes

// | |

// ↓ ↓

// construct(finish, x); insert_aux(end(), x);

// ++finish; |

// |------ 内存不足, 重新分配

// | 大小为原来的2倍

// new_finish = data_allocator::allocate(len); <stl_alloc.h>

// uninitialized_copy(start, position, new_start); <stl_uninitialized.h>

// construct(new_finish, x); <stl_construct.h>

// ++new_finish;

// uninitialized_copy(position, finish, new_finish); <stl_uninitialized.h>

void push_back(const T& x)

{

// 内存满足条件则直接追加元素, 否则需要重新分配内存空间

if (finish != end_of_storage)

{

construct(finish, x);

++finish;

}

else

insert_aux(end(), x);

}

// 在指定位置插入元素

// insert(iterator position, const T& x)

// |

// |------------ 容量是否足够 && 是否是end()?

// |

// -------------------------------------------

// No | | Yes

// | |

// ↓ ↓

// insert_aux(position, x); construct(finish, x);

// | ++finish;

// |-------- 容量是否够用?

// |

// --------------------------------------------------

// Yes | | No

// | |

// ↓ |

// construct(finish, *(finish - 1)); |

// ++finish; |

// T x_copy = x; |

// copy_backward(position, finish - 2, finish - 1); |

// *position = x_copy; |

// ↓

// data_allocator::allocate(len); <stl_alloc.h>

// uninitialized_copy(start, position, new_start); <stl_uninitialized.h>

// construct(new_finish, x); <stl_construct.h>

// ++new_finish;

// uninitialized_copy(position, finish, new_finish); <stl_uninitialized.h>

// destroy(begin(), end()); <stl_construct.h>

// deallocate();

iterator insert(iterator position, const T& x)

{

size_type n = position - begin();

if (finish != end_of_storage && position == end())

{

construct(finish, x);

++finish;

}

else

insert_aux(position, x);

return begin() + n;

}

iterator insert(iterator position) { return insert(position, T()); }

void pop_back()

{

–finish;

destroy(finish);

}

iterator erase(iterator position)

{

if (position + 1 != end())

copy(position + 1, finish, position);

–finish;

destroy(finish);

return position;

}

iterator erase(iterator first, iterator last)

{

iterator i = copy(last, finish, first);

// 析构掉需要析构的元素

destroy(i, finish);

finish = finish - (last - first);

return first;

}

// 调整size, 但是并不会重新分配内存空间

void resize(size_type new_size, const T& x)

{

if (new_size < size())

erase(begin() + new_size, end());

else

insert(end(), new_size - size(), x);

}

void resize(size_type new_size) { resize(new_size, T()); }

void clear() { erase(begin(), end()); }

protected:

// 分配空间, 并且复制对象到分配的空间处

iterator allocate_and_fill(size_type n, const T& x)

{

iterator result = data_allocator::allocate(n);

uninitialized_fill_n(result, n, x);

return result;

}

// 提供插入操作

// insert_aux(iterator position, const T& x)

// |

// |---------------- 容量是否足够?

// ↓

// -----------------------------------------

// Yes | | No

// | |

// ↓ |

// 从opsition开始, 整体向后移动一个位置 |

// construct(finish, *(finish - 1)); |

// ++finish; |

// T x_copy = x; |

// copy_backward(position, finish - 2, finish - 1); |

// *position = x_copy; |

// ↓

// data_allocator::allocate(len);

// uninitialized_copy(start, position, new_start);

// construct(new_finish, x);

// ++new_finish;

// uninitialized_copy(position, finish, new_finish);

// destroy(begin(), end());

// deallocate();

template <class T, class Alloc>

void insert_aux(iterator position, const T& x)

{

if (finish != end_of_storage) // 还有备用空间

{

// 在备用空间起始处构造一个元素，并以vector最后一个元素值为其初值

construct(finish, *(finish - 1));

++finish;

T x_copy = x;

copy_backward(position, finish - 2, finish - 1);

*position = x_copy;

}

else // 已无备用空间

{

const size_type old_size = size();

const size_type len = old_size != 0 ? 2 * old_size : 1;

// 以上配置元素：如果大小为0，则配置1（个元素大小）

// 如果大小不为0，则配置原来大小的两倍

// 前半段用来放置原数据，后半段准备用来放置新数据

iterator new_start = data_allocator::allocate(len); // 实际配置

iterator new_finish = new_start;

// 将内存重新配置

try

{

// 将原vector的安插点以前的内容拷贝到新vector

new_finish = uninitialized_copy(start, position, new_start);

// 为新元素设定初值 x

construct(new_finish, x);

// 调整水位

++new_finish;

// 将安插点以后的原内容也拷贝过来

new_finish = uninitialized_copy(position, finish, new_finish);

}

catch(…)

{

// 回滚操作

destroy(new_start, new_finish);

data_allocator::deallocate(new_start, len);

throw;

}

// 析构并释放原vector

destroy(begin(), end());

deallocate();

// 调整迭代器，指向新vector

start = new_start;

finish = new_finish;

end_of_storage = new_start + len;

}

}

// 在指定位置插入n个元素

// insert(iterator position, size_type n, const T& x)

// |

// |---------------- 插入元素个数是否为0?

// ↓

// -----------------------------------------

// No | | Yes

// | |

// | ↓

// | return;

// |----------- 内存是否足够?

// |

// -------------------------------------------------

// Yes | | No

// | |

// |------ (finish - position) > n? |

// | 分别调整指针 |

// ↓ |

// ---------------------------- |

// No | | Yes |

// | | |

// ↓ ↓ |

// 插入操作, 调整指针 插入操作, 调整指针 |

// ↓

// data_allocator::allocate(len);

// new_finish = uninitialized_copy(start, position, new_start);

// new_finish = uninitialized_fill_n(new_finish, n, x);

// new_finish = uninitialized_copy(position, finish, new_finish);

// destroy(start, finish);

// deallocate();

template <class T, class Alloc>

void insert(iterator position, size_type n, const T& x) //注意看，这里传进来的是拷贝

{

// 如果n为0则不进行任何操作

if (n != 0)

{

if (size_type(end_of_storage - finish) >= n)

{ // 剩下的备用空间大于等于“新增元素的个数”

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）

Docker步步实践

目录文档：

①Docker简介

②基本概念

③安装Docker

④使用镜像：

⑤操作容器：

⑥访问仓库：

⑦数据管理：

⑧使用网络：

⑨高级网络配置：

⑩安全：

⑪底层实现：

⑫其他项目：

711383778575)]

①Docker简介

②基本概念

③安装Docker

[外链图片转存中…(img-eFlCqmaK-1711383778576)]

④使用镜像：

[外链图片转存中…(img-YdDiytFq-1711383778576)]

⑤操作容器：

[外链图片转存中…(img-aq44HsKV-1711383778577)]

⑥访问仓库：

[外链图片转存中…(img-kxIGN4QM-1711383778577)]

⑦数据管理：

[外链图片转存中…(img-CkOhWxx3-1711383778577)]

⑧使用网络：

[外链图片转存中…(img-05BuUSQO-1711383778578)]

⑨高级网络配置：

[外链图片转存中…(img-VLOsjpvX-1711383778578)]

⑩安全：

[外链图片转存中…(img-Oys0Hm7G-1711383778578)]

⑪底层实现：

[外链图片转存中…(img-b7Jsa9dT-1711383778579)]

⑫其他项目：

[外链图片转存中…(img-n404K6Yg-1711383778579)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录