【C++详解】——vector类

news2024/11/25 13:02:12

📖 前言：本期介绍vector类。

目录

  • 🕒 1. vector的介绍
  • 🕒 2. vector的使用
    • 🕘 2.1 定义
    • 🕘 2.2 iterator
    • 🕘 2.3 空间增长
    • 🕘 2.4 增删查改
  • 🕒 2. vector的模拟实现
    • 🕘 2.1 构造函数
      • 🕤 2.1.1 无参构造
      • 🕤 2.1.2 拷贝构造
      • 🕤 2.1.3 构造并初始化n个val
    • 🕘 2.2 iterator
    • 🕘 2.3 空间增长
    • 🕘 2.4 增删查改
      • 🕤 2.4.1 insert
      • 🕤 2.4.2 erase
      • 🕤 2.4.3 swap
    • 🕘 2.5 其他
  • 🕒 3. 深拷贝问题
    • 🕘 3.1 vector<vector< int >>
    • 🕘 3.2 vector< string >
  • 🕒 4. 模拟实现vector汇总

🕒 1. vector的介绍

  1. vector是表示可变大小数组的序列容器（可以理解为顺序表）。
  2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
  3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
  4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
  5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
  6. 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好。

使用STL的三个境界：能用，明理，能扩展 ，那么下面学习vector，我们也是按照这个方法去学习。

🕒 2. vector的使用

🔎 vector文档介绍
对于vector内部的成员函数，基本上和string相同，因此本文章在模拟实现之前只介绍大多使用函数的函数名以及功能，具体细节会在模拟实现中解释。

🕘 2.1 定义

构造函数声明接口说明
vector()（重点）无参构造
vector（size_type n, const value_type& val = value_type()）构造并初始化n个val
vector (const vector& x)（重点）拷贝构造
vector (InputIterator first, InputIterator last);使用迭代器进行初始化构造

🕘 2.2 iterator

iterator的使用接口说明
begin + end（重点）获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置的iterator/const_iterator
rbegin + rend获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的reverse_iterator

在这里插入图片描述
这里会出现迭代器失效问题，如图我们发现迭代器可以看成指向某一数据的指针（实际上不一定是指针），但如果出现了扩容的情况（统一看成异地扩容）那么这个迭代器指向的位置就不再是我们想要进行操作的位置，这就是典型的迭代器失效问题，也就是野指针问题。具体介绍将会在下面的模拟实现中进行解释。

🕘 2.3 空间增长

容量空间接口说明
size获取数据个数
capacity获取容量大小
empty判断是否为空
resize（重点）改变vector的size
reserve （重点）改变vector的capacity
  • capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。
  • reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题（即可以直接将扩容一次性到位）。如果比当前容量小时，不缩容，因为缩容有代价，以空间换时间。
  • resize在开空间的同时还会进行初始化，影响size。
// 测试vector的默认扩容机制
void TestVectorExpand()
{
	size_t sz;
	vector<int> v;
	v.reserve(100);
	sz = v.capacity();
	cout << "making v grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
}

🕘 2.4 增删查改

增删查改接口说明
push_back（重点）尾插
pop_back （重点）尾删
find查找（注意这个是算法模块实现，不是vector的成员接口）
insert在position之前插入val
erase删除position位置的数据
swap交换两个vector的数据空间
operator[] （重点）像数组一样访问

🕒 2. vector的模拟实现

首先定义一个vector类：

template<class T>
class vector
{
public:
    typedef T* iterator;
    typedef const T* const_iterator;
    
    T& operator[](size_t pos)
    {
        assert(pos < size());
        return _start[pos];
    }

    const T& operator[](size_t pos) const
    {
        assert(pos < size());
        return _start[pos];
    }
    
private: 
    iterator _start; // 0
    iterator _finish; // size
    iterator _endofstorage; // capacity
};

🕘 2.1 构造函数

🕤 2.1.1 无参构造

vector()
    :_start(nullptr)
        ,_finish(nullptr)
        ,_endofstorage(nullptr)
    {}

🕤 2.1.2 拷贝构造

对于拷贝构造有两种写法：

  • 传统写法：开空间、赋值
  • 现代写法：通过迭代器的初始化构造
//传统写法 v2(v1)
    vector(const vector<T>& v)
    :_start(nullptr)
        , _finish(nullptr)
        , _endofstorage(nullptr)
    {
        reserve(v.capacity());
        for (const auto& e : v) // 必须&， 否则会拷贝构造调用拷贝构造，因为如果每一个元素(T)也都是vector，这就会导致拷贝构造调用拷贝构造
        {
            push_back(e);
        }
    }

// 现代写法
template <class InputIterator>
vector(InputIterator first, InputIterator last) // 迭代器初始化
    :_start(nullptr)
    , _finish(nullptr)
    , _endofstorage(nullptr)
{
    while (first != last)
    {
        push_back(*first);
        ++first;
    }
}

vector(const vector<T>& v)
    :_start(nullptr)
    , _finish(nullptr)
    , _endofstorage(nullptr)
{
    vector<T> tmp(v.begin(), v.end());
    swap(tmp); // this和tmp进行swap
}

🕤 2.1.3 构造并初始化n个val

vector(size_t n, const T& val = T())
    :_start(nullptr)
    , _finish(nullptr)
    , _endofstorage(nullptr)
{
    reserve(n);
    for(size_t i = 0; i < n; i++)
    {
        push_back(val);
    }
}

在测试的时候仅仅这样是会出错的，调试也印证了重载函数不会走上面函数，而是会走迭代器。原因为n是size_t而不是int类型，调用此函数就会发生隐式类型转换，编译器觉得不合适，便寻找更好的选择，于是找到了迭代器。解决方案就是再重载一个函数：vector(int n, const T& val = T())。为什么不直接将上一个函数的size_t改成int类型呢？因为我们是在模拟实现库中的vector。

🕘 2.2 iterator

iterator begin()
{
    return _start;
}

iterator end()
{
    return _finish;
}
const_iterator begin() const
{
    return _start;
}
const_iterator end() const
{
    return _finish;
}

🕘 2.3 空间增长

size_t size() const 
{
    return _finish - _start;
}

size_t capacity() const
{
    return _endofstorage - _start;
}
bool empty() const
{
    return _finish == _start;
}

void resize(size_t n, T val = T())//这里的val是缺省
{
    if (n > capacity())
    {
        reserve(n);
    }
    if (n > size())
    {
        while (_finish < _start + n)
        {
            *_finish = val;
            ++_finish;
        }
    }
    else
    {
        _finish = _start + n;
    }
}

void reserve(size_t n) // 注意迭代器失效问题
{

    if (n > capacity())
    {
        size_t oldSize = size();
        T* tmp = new T[n];
        if (_start)
        {
            memcpy(tmp, _start, sizeof(T) * size());
            delete[] _start;
        }
        _start = tmp;
        _finish = tmp + oldSize;
        _endofstorage = _start + n;
    }
}

上面的reserve提到了迭代器失效问题，代码中已解决，即oldSize记录了size()的大小。那如果不记录size()的大小，那么_finish = tmp + size()中的size()由于之前的空间被销毁，也会被置为0,，此时的_finish就与_start就相同。

🕘 2.4 增删查改

这里需要注意迭代器失效问题，迭代器失效与扩容机制息息相关，而增删查改会频繁的调用扩容机制。

首先介绍不涉及迭代器失效的问题的成员函数：

void push_back(const T& x)
{
    if (_finish == _endofstorage)
    {
        size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
        reserve(newCapacity);
    }

    *_finish = x;
    ++_finish;

}
void pop_back()
{
    assert(!empty());
    --_finish;
}

下面看看需要考虑迭代器失效问题的成员函数

🕤 2.4.1 insert

// 迭代器失效问题：异地扩容导致的野指针问题
iterator insert(iterator pos, const T& val) // 不传引用是因为有左值的影响：常量，即v.begin()
{
    assert(pos >= _start);
    assert(pos < _finish);
    if (_finish == _endofstorage)
    {
        size_t len = pos - _start; // 处理失效问题，记录相对位置
        size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
        reserve(newCapacity);

        //扩容导致pos迭代器失效，需要更新处理一下
        pos = _start + len;
    }

    //挪动数据
    iterator end = _finish - 1;
    while (end >= pos)
    {
        *(end + 1) = *end;
        end--;
    }
    *pos = val;
    ++_finish;

    return pos;
}

对于前插，是一定要考虑扩容问题的，而我们实现的方式也只有异地扩容，因此当我们触发了扩容机制后，就会引起迭代器失效的问题：

为了处理这个迭代器失效的问题，我们提前记录pos与_start的相对位置，即通过len = pos - _start记录，最后更新pos = _start + len，就可以解决这里迭代器失效的问题。

虽然函数内部的迭代器失效问题解决了，但我们知道，在这个函数中的pos只是外部pos的一份临时拷贝，改变这里的pos外部的pos并不会改变，因此外部的pos也会由于异地扩容之后导致野指针，那么我们可以采用返回值更新pos。

🕤 2.4.2 erase

iterator erase(iterator pos)
{
    assert(pos >= _start && pos < _finish);
    iterator begin = pos + 1;
    while (begin < _finish)
    {
        *(begin-1) = *begin;
        ++begin;
    }

    --_finish;
    return pos;
}

🕤 2.4.3 swap

void swap(vector<T>& v)
{
    std::swap(_start, v._start);
    std::swap(_finish, v._finish);
    std::swap(_endofstorage, v._endofstorage);
}

🕘 2.5 其他

~vector()//析构
{
    delete[] _start;
    _start = _finish = _endofstorage = nullptr;
}

// v1 = v2
// v1 = v1;  // 极少数情况，能保证正确性，所以这里就这样写没什么问题

vector<T>& operator=(vector<T> v) // 由于直接swap，因此不能传引用
{
    swap(v);
    return *this;
}
void clear()
{
    _finish = _start; // 不能置空，会发现内存泄漏
}

🕒 3. 深拷贝问题

🕘 3.1 vector<vector< int >>

在这里插入图片描述
我们用上面模拟实现的代码进行观察

void test_vectorarray()
{
    vector<vector<int>> vv;
    vector<int> v(5, 1);
    vv.push_back(v);
    vv.push_back(v);
    vv.push_back(v);
    vv.push_back(v);

    for (size_t i = 0; i < vv.size(); i++)
    {
        for (size_t j = 0; j < vv[i].size(); j++)
        {
            cout << vv[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}

在这里插入图片描述

可以看到，插入四行是没问题的，那再插入一行（加上一个vv.push_back(v);）会怎么样呢

在这里插入图片描述
很明显，扩容出了问题，根据经验，大概率是异地扩容后出现了浅拷贝问题，即我们异地扩容产生的变量的指向仍然是之前指向的位置，并且由于异地扩容之后，会delete[]原空间，这就导致异地扩容的指向也变成了野指针。

在这里插入图片描述
当我们到了第五个push_back，也就是需要扩容的时候，我们发现：tmp与原本_start的位置指向的是同一个位置（注意外部的_start与内部的第一个_start指向的位置是一样的），这是由于memcpy引起的，而我们知道，memcpy所引起的异地扩容会释放旧空间，即释放旧位置所指向的位置，但这一释放，就导致了新开辟的tmp内部的指针变量指向的空间也被释放了。

既然浅拷贝的memcpy不行，那我们就可以通过赋值的方式在拷贝中开辟新空间，进行深拷贝：

void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldSize = size();
				T* tmp = new T[n];

				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T)*oldSize);
					for (size_t i = 0; i < oldSize; ++i)
					{
						tmp[i] = _start[i];
					}

					delete[] _start;
				}

				_start = tmp;
				_finish = tmp + oldSize;
				_endofstorage = _start + n;
			}
		}

即将reserve中的memcpy换成如图所示的方式，这样赋值拷贝会开辟新空间（上面的代码中就是开辟了新空间），我们就可以避免浅拷贝的问题。
在这里插入图片描述
因此我们也需要注意： 在C++中要避免使用C语言中的函数：memcpy、realloc、malloc等

🕘 3.2 vector< string >

事实上，string与vector<int>的道理是相同的，如果我们仍然用memcpy，会发现在需要扩容的过程中仍然出现浅拷贝造成的错误，用赋值就没有问题。由此可以理解，自定义类型的情况下都会发生这种扩容出现的问题，而内置类型并不会发生。

void test_vectorstring()
{
    vector<string> v;
    v.push_back("1111111111111");
    v.push_back("1111111111111");
    v.push_back("1111111111111");
    v.push_back("1111111111111");
    v.push_back("1111111111111"); // 扩容
    for (size_t i = 0; i < v.size(); i++)
    {
        for (size_t j = 0; j < v[i].size(); j++)
        {
            cout << v[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}

🕒 4. 模拟实现vector汇总

//myvector.h
#pragma once

namespace myvector
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

		T& operator[](size_t pos)
		{
			assert(pos < size());
			return _start[pos];
		}

		const T& operator[](size_t pos) const
		{
			assert(pos < size());
			return _start[pos];
		}

		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{}

		//传统写法 v2(v1)
		//vector(const vector<T>& v)
		//	:_start(nullptr)
		//	, _finish(nullptr)
		//	, _endofstorage(nullptr)
		//{
		//	reserve(v.capacity());
		//	for (const auto& e : v) // 必须&， 否则会拷贝构造调用拷贝构造，因为如果每一个元素(T)也都是vector，这就会导致拷贝构造调用拷贝构造
		//	{
		//		push_back(e);
		//	}
		//}

		vector(int n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

		vector(size_t n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);
			for (size_t i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

		// 现代写法
		template <class InputIterator>
		vector(InputIterator first, InputIterator last) // 迭代器初始化
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			vector<T> tmp(v.begin(), v.end());
			swap(tmp); // this和tmp进行swap
		}

		~vector()
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}
		// v1 = v2
		// v1 = v1;  // 极少数情况，能保证正确性，所以这里就这样写没什么问题

		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}
		
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldSize = size();
				T* tmp = new T[n];

				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T)*oldSize);
					for (size_t i = 0; i < oldSize; ++i)
					{
						tmp[i] = _start[i];
					}

					delete[] _start;
				}

				_start = tmp;
				_finish = tmp + oldSize;
				_endofstorage = _start + n;
			}
		}

		void resize(size_t n, T val = T())
		{
			if (n > capacity())
			{
				reserve(n);
			}

			if (n > size())
			{
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

		bool empty() const
		{
			return _finish == _start;
		}

		size_t size() const
		{
			return _finish - _start;
		}

		size_t capacity() const
		{
			return _endofstorage - _start;
		}

		void push_back(const T& x)
		{
			if (_finish == _endofstorage)
			{
				size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newCapacity);
			}

			*_finish = x;
			++_finish;
		}

		void pop_back()
		{
			assert(!empty());

			--_finish;
		}

		// 迭代器失效问题：异地扩容导致的野指针问题
		iterator insert(iterator pos, const T& val) // 不传引用是因为有左值的影响：常量，即v.begin()
		{
			assert(pos >= _start);
			assert(pos < _finish);

			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;// 处理失效问题，记录相对位置
				size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newCapacity);

				// 扩容会导致pos迭代器失效，需要更新处理一下
				pos = _start + len;
			}

			// 挪动数据
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}

			*pos = val;
			++_finish;

			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);


			iterator begin = pos + 1;
			while (begin < _finish)
			{
				*(begin - 1) = *(begin);
				++begin;
			}

			--_finish;

			return pos;
		}

		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}

		void clear()
		{
			_finish = _start;
		}

	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};
}

OK，以上就是本期知识点“vector类”的知识啦~~ ，感谢友友们的阅读。后续还会继续更新，欢迎持续关注哟📌~
💫如果有错误❌，欢迎批评指正呀👀~让我们一起相互进步🚀
🎉如果觉得收获满满，可以点点赞👍支持一下哟~

❗ 转载请注明出处
作者：HinsCoder
博客链接：🔎 作者博客主页

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Springboot+ssm微空间私人定向共享文件资料系统java

Springboot+ssm微空间私人定向共享文件资料系统java

目 录 1绪论 1 1.1项目研究的背景 1 1.2开发意义 1 1.3项目研究现状及内容 5 1.4论文结构 5 2开发技术介绍 7 2.1 B/S架构 7 2.2 MySQL 介绍 7 2.3 MySQL环境配置 7 2.4 Java语言简介 8 2.5Jsp技术 8 3系统分析 9 3.1可行性分析 9 3.1…
阅读更多...
Android Studio 编译C/C++生成.so文件

Android Studio 编译C/C++生成.so文件

前期准备&#xff1a;下载NDK、CMake方法一&#xff1a;使用AndroidStudio自动创建NativeC/C 项目创建新项目创建项目后&#xff0c;会默认生成两个文件和相关默认配置.若创建好C项目后报错&#xff0c;则需要配置一下NDK路径如果上图配置页面显示无法配置&#xff0c;则需要手…
阅读更多...
【疑难解决】EasyCVR集成宇视SDK关闭“按需直播”，一直未拉流是什么原因？

【疑难解决】EasyCVR集成宇视SDK关闭“按需直播”，一直未拉流是什么原因？

EasyCVR平台不仅能提供丰富的视频能力&#xff0c;还可提供云、边、端分布式海量视频资源的统一管理与运维&#xff0c;从而实现数据采集、处理、汇聚、分析、存储、管理等全环节的视频能力。借助智能分析网关的AI智能检测能力&#xff0c;可实现人脸、人体、车辆、烟火、物体、…
阅读更多...
LeetCode-191-位1的个数

LeetCode-191-位1的个数

1、位运算 我们可以使用位运算来计算二进制串中1的个数。由于异或的性质&#xff0c;0与0异或为0&#xff0c;0与1异或为1&#xff0c;我们可以将n与0进行异或操作&#xff0c;而后逐位判断是否为1&#xff0c;最终将结果进行累加即可。 class Solution { public:int hamming…
阅读更多...
Mybatis 基础1

Mybatis 基础1

Mybatis基础什么是Mybatis什么是框架ORM介绍快速入门环境搭建MyBatis的相关apiResources构建器SqlSessionFactoryBuilder工厂对象SqlSessionFactorySqlSession会话对象MyBatis 映射配置文件映射配置文件介绍查询功能新增功能修改功能删除功能小结Mybatis核心配置文件介绍核心配…
阅读更多...
创建百度百科词条要交费吗？百度百科词条花钱吗？

创建百度百科词条要交费吗？百度百科词条花钱吗？

互联网时代&#xff0c;百度逐渐成为了人们了解信息、搜集信息的主要渠道&#xff0c;越来越多的用户通过百度百科词条认识到了很多知名的人物、产品、品牌或是作品等等&#xff0c;百度百科词条在人们心中的信赖度也是越来越高。 百度百科词条具有权威性&#xff0c;百度百科…
阅读更多...
Spring中Bean的生命周期(包含Spring执行流程)

Spring中Bean的生命周期(包含Spring执行流程)

文章目录一、Spring(Bean)执行流程二、Bean生命周期Bean的生命周期演示总结一、Spring(Bean)执行流程 启动容器(启动项目)读取配置文件(初始化) a) 使用xml注册bean b) 配置bean根(扫描)路径将bean存储到Spring中(存操作): 通过类注解进行扫描和装配将bean从Spring读取出来(取…
阅读更多...
想要协同办公，企业云盘该怎么选？

想要协同办公，企业云盘该怎么选？

信息数字时代&#xff0c;数字资产迎来爆发的同时&#xff0c;资产管理需求也在不断增加。在面对资源容量过大、素材无法大量共享等问题时&#xff0c;怎么让内容生产者和团队管理者更高效进行内容存储&#xff0c;满足项目在多元场景下分发、协作需求&#xff1f;赞奇超级云盘…
阅读更多...
MySQL相关面试题

MySQL相关面试题

文章目录union 和 unionAll 的区别&#xff1f;drop、delete与truncate的区别 &#xff1f;sql 语句如何优化 &#xff1f;什么是事务 &#xff1f;事务的四个特性(ACID) &#xff1f;事务的隔离级别&#xff1f;索引主要有哪几种分类 &#xff1f;什么时候适合添加索引&#x…
阅读更多...
ClickHouse 单机安装及基础知识与 Spark 应用

ClickHouse 单机安装及基础知识与 Spark 应用

什么是 ClickHouse？ ClickHouse 是一个用于联机分析(OLAP)的列式数据库管理系统(DBMS)。 在传统的行式数据库系统中，数据按如下顺序存储： 处于同一行中的数据总是被物理的存储在一起。 常见的行式数据库系统有：MySQL、Postgres等。 在列式数据库系统中，数据按如下的顺…
阅读更多...
ansible的常用模块介绍

ansible的常用模块介绍

ansible 常用命令/usr/bin/ansible　 #Ansibe AD-Hoc 临时命令执行工具&#xff0c;常用于临时命令的执行/usr/bin/ansible-doc #Ansible 模块功能查看工具/usr/bin/ansible-galaxy　　#下载/上传优秀代码或Roles模块 的官网平台&#xff0c;基于网络的/usr/bin/ansible-playbo…
阅读更多...
第八章 Flink集成Iceberg的DataStreamAPI、TableSQLAPI详解

第八章 Flink集成Iceberg的DataStreamAPI、TableSQLAPI详解

1、概述 ​ 目前Flink支持使用DataStream API 和SQL API方式实时读取和写入Iceberg表&#xff0c;建议使用SQL API方式实时读取和写入Iceberg表。 Iceberg支持的Flink版本为1.11.x版本以上&#xff0c;以下为版本匹配关系&#xff1a; Flink版本Iceberg版本备注Flink1.11.XI…
阅读更多...
Windows 安装 Docker

Windows 安装 Docker

一、Docker 官网 Dockerhttps://hub.docker.com/下载地址 window Docker 下载地址https://desktop.docker.com/win/main/amd64/Docker%20Desktop%20Installer.exe 二、安装 检测是否已经安装了docker docker -v 如下图 &#xff1a; 如果没有安装&#xff0c;则在第一点下…
阅读更多...
【Spark分布式内存计算框架——Spark Core】5. RDD 函数补充：关联函数与练习

【Spark分布式内存计算框架——Spark Core】5. RDD 函数补充：关联函数与练习

关联函数 当两个RDD的数据类型为二元组Key/Value对时&#xff0c;可以依据Key进行关联Join。 首先回顾一下SQL JOIN&#xff0c;用Venn图表示如下&#xff1a; RDD中关联JOIN函数都在PairRDDFunctions中&#xff0c;具体截图如下&#xff1a; 具体看一下join&#xff08;等…
阅读更多...
1624_MIT 6.828 stabs文档信息整理_上

1624_MIT 6.828 stabs文档信息整理_上

全部学习汇总&#xff1a; GreyZhang/g_unix: some basic learning about unix operating system. (github.com) 前面为了完成MIT 6.828的堆栈信息解析大概看了一下这个文档&#xff0c;现在把看过的信息简单整理一下。 1. stabs主要是为调试器提供调试信息用的描述数据&#x…
阅读更多...
11.XMLHttpRequest的进阶用法

11.XMLHttpRequest的进阶用法

目录 1 设置HTTP的请求时限 2 Formdata对象 2.1 简单使用 2.2 Formdata直接获取表单数据 2.3 上传文件 2.4 上传文件的进度 3 定义API根路径 4 请求出错 上面我们用的都是旧版的XMLHttpRequest&#xff0c;旧版有两个缺点 无法上传文件没有传送数据的进度信息…
阅读更多...
Docker部署ddns-go，动态域名解析公网IPv6地址

Docker部署ddns-go，动态域名解析公网IPv6地址

Docker部署ddns-go&#xff0c;动态域名解析公网IPv6地址 ddns-go&#xff0c;自动获得你的公网 IPv4 或 IPv6 地址&#xff0c;并解析到对应的域名服务。 嫌IPv6地址太难记&#xff1f;ddns来解决&#xff0c;将家里的公网IPv6地址用起来吧&#xff01; 前言 为什么需要DDNS …
阅读更多...
Java设计模式——装饰器模式

Java设计模式——装饰器模式

目录 1.什么是装饰器模式 2.装饰器模式优缺点 3.装饰器模式结构 4.代码示例 1.什么是装饰器模式 装饰器模式&#xff0c;指在不改变原有对象结构的基础情况下&#xff0c;动态地给该对象增加一些额外功能的职责。装饰器模式相比生成子类更加灵活。它属于对象结构型模式。 …
阅读更多...
DCGAN

DCGAN

DCGAN的论文地址[https://arxiv.org/pdf/1511.06434.pdf]。DCGAN是GAN的一个变体&#xff0c;DCGAN就是将CNN和原始的GAN结合到一起&#xff0c;生成网络和鉴别网络都运用到了深度卷积神经网络。DCGAN提高了基础GAN的稳定性和生成结果质量。DCGAN主要是在网络架构上改进了原始的…
阅读更多...
JVET-AC0315：用于色度帧内预测的跨分量Merge模式

JVET-AC0315：用于色度帧内预测的跨分量Merge模式

ECM采用了许多跨分量的预测&#xff08;Cross-componentprediction&#xff0c;CCP&#xff09;模式&#xff0c;包括跨分量包括跨分量线性模型&#xff08;CCLM&#xff09;、卷积跨分量模型&#xff08;CCCM&#xff09;和梯度线性模型&#xff08;GLM&#xff09;&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023