C++:线上课程3_4——3_5(alloc)

已于 2022-04-28 18:56:42 修改
阅读量1.3k 收藏
点赞数
分类专栏： C++(线上) 文章标签： c++ 算法 容器
于 2022-04-24 15:33:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48580892/article/details/124255311
版权

文章目录

一、lambda表达式

1.mutable关键字

int main()
{
	int a = 0;
	auto f1 = [=]
	{
		return a++;//error，修改按值捕获的外部变量
	};
	auto f2 = [=]() mutable
	{
		return a++;//ok
	}
}

class Object
{
	int value;
	mutable int num;
public:
	Object(int x = 0, int y = 0) :value{ x }, num{ y } {}//列表初始化

	int fun() const
	{
		int a = 10;
		a += 10;
		num += 10;//加上mutable关键字才可编译成功
		return value + num;
	}
};

从上面的例子中我们知道，按值捕获得到的外部变量值是在lambda表达式定义时的值。此时所有外部变均被复制了一份存储在lambda表达式变量中。此时虽然修改lambda 表达式中的这些外部变量并不会真正影响到外部，我们却仍然无法修改它们。

那么如果希望去修改按值捕获的外部变量应当怎么办呢?这时，需要显式指明lambda表达式mutable

需要注意的一点是，被 mutable修饰的lambda表达式就算没有参数也要写明参数列表。

2. lambda表达式代码示例

template <class _BI ,class _Fn>
void my_for_each(_BI _first, _BI _last, _Fn _func)
{
	cout << typeid(_Fn).name() << endl;
	for (; _first != _last; ++first)
	{
		_func(*_first);
	}
}
void Print_Ar(int x)//函数指针
{
	printf("%d", x);
}
struct Print//仿函数
{
	void operator()(int x) const
	{
		printf("%d", x);
	}
};
int main()
{
	std::vector<int> ar = { 12,23,34,45,56,67,78 };
	my_for_each(ar.begin(), ar.end(), Print_Ar);
	cout << endl;
	my_for_each(ar.begin(), ar.end(), Print());
	cout << endl;
	//lambda表达式
	my_for_each(ar.begin(), ar.end(), [](int a)->void {printf("%d", a); });
	cout << endl;

	return 0;
}

二、 STL源码剖析（项目）

1. 迭代器

迭代器是一种抽象的设计概念，语言中并没有直接对应于这个概念的事物。《design patterns》一书提供有23种设计样式的完整描述，iterator样式定义如下：提供一种方法，使得依序寻访某个聚合物（容器）所含的各个元素，而又无需暴露该聚合物的内部表述方式。

STL中心思想是将资料容器和演算法分离，彼此独立设计。

2. 代码示例

find适合list容器，也适合查找vector容器

using namespace std;
template<class _BI,class _Ty>
_BI my_find(_BI _first, _BI _last, const _Ty& val)
{
	cout << typeid(_BI).name() << endl;
	for (; _first != _last; ++_first)
	{
		if (*_first == val)
		{
			break;
		}
	}
	return _first;
}
int main()
{
	vector<int> ivec = { 12,23,34,45,56 };
	list<int> ilist = { 1,2,3,4,5,6 };
	deque<int> de = { 12,23,34,45 };

	vector<int>::iterator it = my_find(ivec.begin(), ivec.end(), 12);
	list<int>::iterator il = my_find(ilist.begin(), ilist.end(), 2);

	return 0;
}

在这里插入图片描述

3. 迭代器相应型别

3.1 value type

指得带起所指物件的型别，迭代器在迭代容器时候，除了访问数据，还要指明数据类型

3.2 diefference type

表示迭代器之间的距离，因此，它可以用来表示一个容器的最大容量，因为对于连续空间的容器而言，头尾之间的距离就是其最大容量。

3.3 reference type

  • 常性迭代器：不允许改变所指之物
  • 普通迭代器：允许改变所指之物

3.4 pointer type（指针类型）

  • 常性指针地址
  • 普通指针地址
Item operator*() const
{
	return *ptr;
}
Item operator->() const
{
	return ptr;
}

3.5 iterator_category（迭代器相应型别）

是否能对数据操作的动作，把迭代器分为五类：

  • input iterator：只读迭代器
  • output iterator：可写迭代器
  • forword iterator：正向迭代器
  • bidirectional iterator：双向迭代器
  • random access iterator：随机迭代器

在这里插入图片描述

4.代码示例

编译时候确定调用关系

my_iterator.h

#ifndef MY_ITERATOR_H
#define MY_ITERATOR_H

namespace h
{
typedef int ptrdiff_t;

struct input_iterator_tag {};
struct output_iterator_tag {};
struct forword_iterator_tag :public input_iterator_tag {};
struct bidirectional_iterator_tag :public forword_iterator_tag {};
struct random_access_iterator_tag :public bidirectional_iterator_tag {};

template<class _C,class _Ty,class _D=ptrdiff_t,class _Pointer=_Ty*,class _Reference=_Ty&>
struct iterator
{
	typedef _C               iterator_category;//迭代器类型
	typedef _Ty              value_type;//迭代器迭代数据之物
	typedef _D               difference_type;//差值
	typedef _Pointer         pointer;//指针
	typedef _Reference       reference;//引用类型
};

//类型萃取（泛化版本）
template<class _Iterator>
struct iterator_traits
{
	//构造函数
	iterator_traits() {}
	typedef typename _Iterator::iterator_category   iterator_category;//迭代器类型
	typedef typename _Iterator::value_type          value_type;//迭代器迭代数据之物
	typedef typename _Iterator::difference_type     difference_type;//差值
	typedef typename _Iterator::pointer             pointer;//指针
	typedef typename _Iterator::reference           reference;//引用类型
};

//类型萃取（特化版本）-裸指针
template<class T>
struct iterator_traits<T*>
{
	//构造函数
	iterator_traits() {}
	typedef typename random_access_iterator_tag   iterator_category;//迭代器类型
	typedef typename T                            value_type;//迭代器迭代数据之物
	typedef typename int                          difference_type;//差值
	typedef typename T*                           pointer;//指针
	typedef typename T&                           reference;//引用类型
};
//类型萃取（部分特化版本）-常性指针
template<class T>
struct iterator_traits<const T*>
{
	//构造函数
	iterator_traits() {}
	typedef typename random_access_iterator_tag   iterator_category;//迭代器类型
	typedef typename T                            value_type;//迭代器迭代数据之物
	typedef typename int                          difference_type;//差值
	typedef typename const T*                     pointer;//指针
	typedef typename const T&                     reference;//引用类型
};
//SGI
template<class _II>
inline typename iterator_traits<_II>::iterator_category
iterator_category(const _II&)
{
	typedef typename iterator_traits<_II>::iterator_category cate;
	return cate();
}

//SGI——萃取值类型
template<class _II>
inline typename iterator_traits<_II>::value_type*
value_type(const _II&)
{
	//强转为指针类型
	return static_cast<typename iterator_traits<_II>::value_type*>(0);
}
//正向迭代器
template<class _Ty,class _D>
struct _Forit :public iterator<forword_iterator_tag, _Ty, _D> {};

//双向迭代器
template<class _Ty,class _D>
struct _Bidit :public iterator<bidirectional_iterator_tag, _Ty, _D> {};

//随机迭代器
template<class _Ty,class _D=ptrdiff_t>
struct _Ranit :public iterator<random_access_iterator_tag, _Ty, _D> {};

template<class _II,class _D>
inline void __advance(_II& i, _D n, input_iterator_tag)
{
	while (n--) ++i;
}

template<class _BI, class _D>
inline void __advance(_BI& i, _D n, bidirectional_iterator_tag)
{
	if (n >= 0)//正向
	{
		while (n--) ++i;
	}
	else//逆向
	{
		while (n++) --i;
	}
}

template<class _RAI, class _D>
inline void __advance(_RAI& i, _D n, random_access_iterator_tag)
{
	i += n;
}

template<class _II,class _D>
inline void advance(_II& i, _D n)
{
	iterator_traits<_II>();
	typedef typename iterator_traits<_II>::iterator_category cate;
	__advance(i, n, cate());
	//__advance(i, n, iterator_category(i));
}

//一个一个，效率低下，但是适用于所有迭代器
template<class _II>
inline typename iterator_traits<_II>::difference_type
__distance(_II _F, _II _L, input_iterator_tag)
{
	inline typename iterator_traits<_II>::difference_type n = 0;
	while (_F != _L)
	{
		_F++;
		n++;
	}
	return n;
}

//随机迭代器
template<class _RAI>
inline typename iterator_traits<_RAI>::difference_type
__distance(_RAI _F, _RAI _L, random_access_iterator_tag)
{
	return _L = _F;
}

//计算差值的函数
template<class _II>
inline typename iterator_traits<_II>::difference_type
distance(_II _F, _II _L)
{
	return __distance(_F, _L, iterator_category(_F));
}

}


#endif

my_list.h

#ifndef MY_LIST_H
#define MY_LIST_H
#include"my_iterator.h"
namespace h
{
template<class _Ty>
class my_list
{
public:
	class iteratir;
	class const_iterator;
	//双向迭代器
	class const_iterator :public h::_Bidit<_Ty, int> {};
	class iterator :public const_iterator {};
};
}
#endif

my_vector.h

#ifndef MY_VECTOR_H
#define MY_VECTOR_H
#include"my_iterator.h"
namespace h
{
template<class _Ty>
class my_vector
{
public:
	class iteratir;
	class const_iterator;
	//随机迭代器
	class const_iterator :public h::_Ranit<int, int> {};
	class iterator :public const_iterator {};
};
}
#endif

my_hash_table.h

#ifndef MY_HASHTABLE_H
#define MY_HASHTABLE_H
#include"my_iterator.h"
namespace h
{
	template<class _Ty>
class my_hashtable
{
public:
	class iterator;
	class const_iterator;
	//正向迭代器
	class const_iterator :public h::_Forit<_Ty, int> {};
	class iterator :public const_iterator {};
};
}
#endif

int main

#include<queue>
#include<unordered_map>
#include<set>
#include"my_iterator.h"
#include"my_list.h"
#include"my_vector.h"
#include"my_hash_table.h"

using namespace std;

int main()
{
	vector<int> ar = { 12,23,34,45,56 };//随机迭代器
	list<int> ilist = { 1,2,3,4,5,6,7 };//双向迭代器

	std::vector<int>::iterator sit = ar.begin();
	std::vector<int>::iterator eit = ar.end();

	//计算差值函数,计算两迭代器之间的距离
	int len = std::distance(eit, sit);
	len = std::distance(ilist.end(), ilist.begin());

	return 0;
}

my_type_traits

#ifndef MY_TYPE_TRAITS_H
#define MY_TYPE_TRAITS_H
namespace h
{
	//类型萃取
	struct __true_type {};
	struct __false_type {};

	template<class type>
	struct __type_traits
	{
		typedef __true_type  this_dummy_member_must_be_first;
		typedef __false_type  has_trivial_default_constructor;
		typedef __false_type  has_trivial_copy_constructor;
		typedef __false_type  has_trivial_assignment_operator;
		typedef __false_type  has_trivial_destructor;
		typedef __false_type  is_POD_type; // struct int 
	};
	//特化版本
	template<> struct __type_traits<char>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	//有符号特化版本
	template<> struct __type_traits<signed char>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	//无符号特化版本
	template<> struct __type_traits<unsigned char>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	//短整型特化版本
	template<> struct __type_traits<short>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	//无符号短整型特化版本
	template<> struct __type_traits<unsigned short>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	//整型特化版本
	template<> struct __type_traits<int>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	//无符号整型特化版本
	template<> struct __type_traits<unsigned int>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	//长整型特化版本
	template<> struct __type_traits<long int>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	//无符号长整型特化版本
	template<> struct __type_traits<unsigned long int>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	
	template<> struct __type_traits<long long>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	template<> struct __type_traits<unsigned long long>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	template<> struct __type_traits<float>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};

	template<> struct __type_traits<double>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};

	template<> struct __type_traits<long double>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
	//指针
	template<class T>
	struct __type_traits<T*>
	{
		typedef __true_type  has_trivial_default_constructor;
		typedef __true_type  has_trivial_copy_constructor;
		typedef __true_type  has_trivial_assignment_operator;
		typedef __true_type  has_trivial_destructor;
		typedef __true_type  is_POD_type; // struct int 
	};
}
#endif

my_alloc.h

#ifndef MY_ALLOC_H
#define MY_ALLOC_H
#include<iostream>

namespace h
{
#if 0
#include<new>
#define __THROW_BAD_ALLOC throw std::bad_alloc;
#elif !defined(__THROW_BAD_ALLOC)
#define __THROW_BAD_ALLOC std::cerr<<"out of memory"<<std::endl; exit(1)
#endif

	template<int inst>
	//一级空间配置器
	class __malloc_alloc_template
	{
	public:
		using PFUN = void (*)();
	private:
		//当allocate函数申请空间不足时候调用
		static void* oom_malloc(size_t n)
		{
			void* result = NULL;
			void (*my_malloc_handler) () = nullptr;
			for (;;)
			{
				my_malloc_handler = __malloc_alloc_oom_handler;
				if (nullptr == my_malloc_handler)
				{
					__THROW_BAD_ALLOC;//宏抛出异常，或者终止程序
				}
				//释放更多内存
				my_malloc_handler();
				result = malloc(n);
				if (nullptr != result)
				{
					return result;
				}
			}
		}
		//当reallocate函数扩容不足时候调用
		static void* oom_realloc(void* p, size_t new_sz)
		{
			void* result = NULL;
			void (*my_malloc_handler) () = nullptr;
			for (;;)
			{
				my_malloc_handler = __malloc_alloc_oom_handler;
				if (nullptr == my_malloc_handler)
				{
					__THROW_BAD_ALLOC;
				}
				my_malloc_handler();
				result = realloc(p, new_sz);
				if (nullptr != result)
				{
					return result;
				}
			}
		}
		//函数指针——解决内存不足问题
		static PFUN __malloc_alloc_oom_handler;
	//用户函数
	public:
		//申请空间
		static void* allocate(size_t n)
		{
			void* result = malloc(n);
			if (nullptr == result)
			{
				result = oom_malloc(n);
			}
			return result;
		}
		//释放空间
		static void deallocate(void* p, size_t n)
		{
			free(p);
		}
		//扩容函数
		static void* reallocate(void* p, size_t old_sz, size_t new_sz)
		{
			void* result = realloc(p, new_sz);
			if (nullptr == result)
			{
				result = oom_realloc(p, new_sz);
			}
			return result;
		}
		//解决内存不足情况
		static  PFUN set_malloc_handler(PFUN p)
		{
			PFUN old = __malloc_alloc_oom_handler;
			__malloc_alloc_oom_handler = p;
			return old;
		}
	};
	template<int inst>
	typename __malloc_alloc_template<inst>::PFUN
		//类型名里面的静态成员
		__malloc_alloc_template<inst>::__malloc_alloc_oom_handler = nullptr;

	//typedef __malloc_alloc_template<0> malloc_alloc;
	using malloc_alloc = __malloc_alloc_template<0>;//重命名

	enum { __ALIGN = 8 };
	enum { __MAX_BYTES = 128 };
	enum { __NFREELISTS = __MAX_BYTES / __ALIGN }; // 16

	template<bool threads, int inst>
	class __default_alloc_template
	{
	private:
		union obj
		{
			union obj* free_list_link; // next;
			//char client_data[1];
		};
	private:
		//自由链表
		static obj* volatile free_list[__NFREELISTS];
		//内存池的起始位置
		static char* start_free;
		static char* end_free;
		static size_t heap_size;//从堆区申请的总空间数
		//提升函数：8的倍数
		static size_t ROUND_UP(size_t bytes)
		{
			return (bytes + __ALIGN - 1) & ~(__ALIGN - 1);
		}
		//哈希函数：申请块的数字
		static size_t FREELIST_INDEX(size_t bytes)
		{
			return (bytes + __ALIGN - 1) / __ALIGN - 1;
		}
		//填充函数
		static char* chunk_alloc(size_t size, int& nobjs);
		static void* refill(size_t size);
	public:
		static void* allocate(size_t size)
		{
			if (size > (size_t)__MAX_BYTES)
			{
				return malloc_alloc::allocate(size);//转给一级配置器
			}
			obj* result = nullptr;
			obj* volatile* my_free_list = nullptr;//链表
			my_free_list = free_list + FREELIST_INDEX(size);
			result = *my_free_list;
			if (nullptr == result)
			{

			}
			*my_free_list = result->free_list_link;
			return result;
		}
		static void deallocate(void* p, size_t n)
		{
			if (n > (size_t)__MAX_BYTES)
			{
				malloc_alloc::deallocate(p, n);
				return;
			}

		}
		static void* reallocate(void* p, size_t old_sz, size_t new_sz); // 
	};


	template<bool threads, int inst>
	typename __default_alloc_template<threads, inst>::obj* volatile
		__default_alloc_template<threads, inst>::free_list[__NFREELISTS] = {};

	template<bool threads, int inst>
	char* __default_alloc_template<threads, inst>::start_free = nullptr;

	template<bool threads, int inst>
	char* __default_alloc_template<threads, inst>::end_free = nullptr;

	template<bool threads, int inst>
	size_t __default_alloc_template<threads, inst>::heap_size = 0;


}
#endif

my_construct.h

#ifndef MY_CONSTRUCT_H
#define MY_CONSTRUCT_H
#include"my_iterator.h"
#include"my_type_traits.h"
namespace h
{
	template<class T1, class T2>
	inline void construct(T1* p, const T2& val)
	{
		new (p) T1(val);//定位new构建
	}
	template<class T>
	inline void construct(T* p)
	{
		new (p) T();
	}

	template<class T>
	inline void destroy(T* p)
	{
		p->~T();
	}
	template<class _FI>
	inline void __destroy_aux(_FI _F, _FI _L, h::__true_type)
	{}
	template<class _FI>
	inline void __destroy_aux(_FI _F, _FI _L, h::__false_type)
	{
		for (; _F != _L; ++_F)
		{
			destroy(&*_F);//只析构迭代器所指对象，迭代器本身并未失效
		}
	}
	template<class _FI, class T>
	inline void __destroy(_FI _F, _FI _L, T*) // value_type;
	{
		//cout << typeid(T).name() << endl;
		//h::__type_traits<T>();
		typedef typename yhp::__type_traits<T>::has_trivial_destructor dest;
		__destroy_aux(_F, _L, dest());
	}
	template<class _FI>
	inline void destroy(_FI _F, _FI _L)
	{
		__destroy(_F, _L, yhp::value_type(_F));
	}
}
#endif

三、 空间配置器

1. 概念

总是隐藏在一切组件，容器的背后，整个STL所有操作对象都存放在容器中，容器一定需要配置空间以存放对象。空间不一定来自于内存。

2. 内存设计

对象构建前的空间配置，和对象析构的空间释放，由<atl_alloc.h>负责，SGL设计如下：

  • 向系统堆空间要求空间
  • 考虑多线程情况
  • 考虑内存不足情况
  • 考虑小段内存造成内存破碎问题

3.内存池

一级配置器和二级配置器

3.1二级配置器

申请空间太多太小的空间造成内存遂安，额外负担无法避免，毕竟系统要靠多出来的空间来管理内存，额外负担所占的比例就越大，空间浪费越大。
如果申请的内存块足够大，大于128
volatile 在取值时，必须从内存里面取值。
在这里插入图片描述

何小柒（qi)～
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++内存分配详解四：std::alloc行为剖析
qq_34269632的博客
04-12 3085
C++标准容器分配器的动作详细分析
Tensorflow2.0 之Could not create cudnn handle: CUDNN_STATUS_ALLOC_FAILED问题
01-20
在TensorFlow 2.0中，用户可能会遇到一个与CuDNN相关的错误，即"Could not create cudnn handle: CUDNN_STATUS_ALLOC_FAILED"。这个错误通常发生在尝试使用GPU资源时，尤其是涉及到CuDNN（NVIDIA CUDA Deep Neural ...
十款在线C++编译器大揭秘：编码利器、性能测评、实时协作一网打尽
最新发布
Francis的博客
12-05 6874
在线编译器目录1.wanbox2.onlinecompilers3.quick-bench4.cppinsights5.godbolt6.coliru7.rextester8.ideone9.paiza10.judge0最近自己环境出了点问题，想找点在线的编译器去跑，并且支持不同的cpp标准，于是乎有了这篇文章～1.wanbox特性：支持多种语言、多个版本，支持分享。这个网站的特点在于支持的C++...
C++ 在栈上分配内存
huang714的专栏
01-02 5846
malloc与alloc的区别 malloc()与 alloc() C语言跟内存分配方式 （1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。 （2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配...
C++的空间分配器allocator
sinat_31608641的博客
07-24 3681
一、背景 在STL中，Memory Allocator 处于最底层的位置，为一切容器提供存储服务，是一切其他组件的基石。对于一般使用 STL 的用户而言，Allocator 是不可见的，如果需要对 STL 进行扩展，如编写自定义的容器，就需要调用 Allocator 的内存分配函数进行空间配置。 ......
无法解析的外部符号”private: char * __cdecl cv::String::allocate(unsigned __int64)” (?allocate@String@cv@@AEAA
01-20
1>—— 已启动生成: 项目: save-image, 配置: Release x64 —— 1>save-image-D435.obj : error LNK2001: 无法解析的外部符号 “private: char * __cdecl cv::String::allocate(unsigned __int64)” (?allocate@...
dma-alloc.rar_dma_alloc_memory
09-14
`dma_alloc_coherent()`函数是Linux内核提供的一种接口，用于为DMA分配内存，确保内存对齐且具有良好的性能。 **DMA内存分配的背景与重要性：** 在传统的I/O操作中，CPU需要先将数据从设备缓冲区复制到系统内存，...
dma-alloc.rar_dma_alloc
09-21
3. **映射和取消映射**：`dma_map_single()`和`dma_map_page()`函数将虚拟内存地址映射到设备可访问的物理地址，而`dma_unmap_single()`和`dma_unmap_page()`则取消这种映射。这是设备开始和结束DMA传输的必要步骤。...
Audio_DeCoder.zip_mpeg/mp3_C/C++_
08-10
在本文中，我们将深入探讨如何使用C/C++编程语言，结合FFmpeg库来实现MPEG/MP3音频的解码。FFmpeg是一个强大的开源多媒体处理框架，它支持多种音频和视频格式的编码、解码、转码以及流媒体操作。 首先，让我们了解...
五、C++内存管理机制 —— 分配器allocator（侯捷）
weixin_43412762的博客
05-02 2296
五、C++内存管理机制 —— 分配器allocator（侯捷）
C++内存管理07 GCC std::alloc 运行模式解读
FairLikeSnow的博客
12-22 498
GCC std::alloc 运行模式解读 首先看如下图，这个图是侯捷老师画的，我向他致敬 前面几章我写的内存管理器，一次只能管理一个内存链表。在这里alloc将会管理16种不同的链表。Free_list[16],其中管理关系如下规则： 0-8 1-16 2-24 3-32 … 14-120 15-128 运行模式解释情景1： 首先要声明一点，在这里alloc会自动将用户传入的内存大小和自身设定...
【C++11新特性】 - 空间配置allocator类
digitalkee的博客
07-11 665
原文链接http://blog.csdn.net/Xiejingfa/article/details/50955295 今天我们来讲讲C++的allocator类。 C++提供了new和delete操作符来管理动态内存空间。new操作通常需要完成两部分工作：一是在系统中申请内存空间，二是在分配的内存上构造对象。delete操作也通常需要完成对应的两部分工作：一个调用相应的析构函数销毁对象，二是回收内存。从这点看，new和delete操作符把内存空间的分配回收与对象的构建销毁紧紧关联在一起。对于new和.
浅谈C++ allocator内存管理（对比new的局限性）
机器学习
12-23 5999
STL中，对内存管理的alloc的设计，迫使我去学习了allocator类。这里对allocator内存管理做了点笔记留给自己后续查阅。allocator类声明、定义于头文件&amp;amp;amp;amp;amp;lt;memory&amp;amp;amp;amp;amp;gt;中的std命名空间内。所以，应该有以下内容位于文件头部… #include &amp;amp;amp;amp;amp;lt;memory&amp;amp;amp;amp;amp;gt; using
2023年6个最受欢迎的C++编程免费在线课程
moocsino的博客
04-08 3215
学习程序设计从C++入手，对于培养利用计算机求解现实问题的计算思维能力具有其他语言无法比拟的优点。​我们从超过200个国内外知名大学和公司的C++课程中，根据注册人数、评分、评论和口碑进行排名，筛选出下面2023年6个最受欢迎的C++免费在线课程，你可以在MOOC学习平台免费注册学习。
C++ 空间的配置与释放 std::alloc
XXXTENTAC1ON的博客
04-25 538
空间配置与释放第一级配置器第二级配置器 对象建立前的空间配置，和对象析构后的空间释放，由<stl_alloc.h>负责，SGI对此的设计哲学如下： 向 system heap 系统堆空间申请 考虑多线程情况 考虑内存不足的情况 考虑过多小块的内存可能造成内存碎片的问题 C++ 的内存分配动作是 ::operator new()，而内存的释放动作是::operator delete()来进行，我们在设计过程中，这两个函数由C的malloc()和free()函数代替，因为 ::operator
C++ 1：C++初始化，输入输出，const关键字，引用，内联，缺省函数，函数重载，左值和右值，函数模板，名字空间
小柒的秃头之路
01-14 443
1.&& 逻辑与 c=a & b; //位与 int* p=&a; //取地址 int& x=a; //引用 #引用（变量别名） （1）引用必须给予初始化 （2）引用不分级，没有空引用 （3）引用不能重载，没有引用的引用 #常引用 const const int& c = a;//常引用，c可以读取a的值，但是不能改变a的值 #引用作为形参，可以改变x和y的值 2.inline函数（内联函数） （1）概念：在C++中，为了解决一些频繁调用的小函数大量消耗栈
C++：可以在线编程的网站
热门推荐
netyeaxi的专栏
10-30 2万+
可以直接在网页上写C++程序，可编译并运行生成结果的在线编程网站
binder_alloc: 4490: binder_alloc_buf, no vma
05-10
3. 如果您是开发人员，则可以尝试使用 adb shell dumpsys meminfo 命令来查看系统内存使用情况，并尝试优化您的应用程序以减少内存使用量。 4. 如果问题仍然存在，请尝试升级您的 Android 系统或重新刷入 ROM。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值