C++实现记录类型内存分配方式的包装类，使对象（或原始类型）只能通过new的方式实例化

最新推荐文章于 2023-03-27 11:03:54 发布
最新推荐文章于 2023-03-27 11:03:54 发布
阅读量572 收藏 1
点赞数 1
分类专栏： 标准C++ 11 基础代码 设计 文章标签： C new
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010300403/article/details/77991018
版权

因为c++new的实现的特殊性（对于非POD类型，new完成之后自动调用对象的构造函数），但是new调用构造并不是在可以重载的new操作符中完成的，这部分的流程通过编程的手段没办法改变（至少以我目前的能力来说），所以想要简单的在new的某个阶段记录新生成的对象来自于new操作是没法做到的。

现在提供一种略微复杂一点（其实也很简单）的方法来标记对象生成来自于new还是栈上申请。

思路：

1，将需要限制分配方式的类型包装成一个类，使之创建的时候一定会调用构造函数

2，重载新类型所有的operator new并调用默认的operator new,记录返回的指针信息

3，在构造函数中比较this指针和记录下来的指针，是否相同

4，如果相同则表示对象是new出来的，否则不是

两种实现方式：

方式1，成员引用方式，代码如下：

#ifndef _ONLYNEW_H_
#define _ONLYNEW_H_

#include <algorithm>
#include <map>
#include <assert.h>

#define THREAD_SAFETY_SIGNNEW

#ifdef THREAD_SAFETY_SIGNNEW
#include <mutex>
#endif

template <typename T>
class SignNew
{
private:
	struct NewRecord
	{
		NewRecord(size_t _ptr, size_t _persize, size_t _membcount) :ptr(_ptr), persize(_persize), membcount(_membcount) {}
		size_t ptr = 0;		//Use size_t instead of void *
		size_t persize = 0;
		size_t membcount = 0;
		bool operator<(const NewRecord& that) const
		{
			return ptr < that.ptr;
		}
		struct FindOp
		{
			FindOp(size_t _ptr) : ptr(_ptr) {}
			bool operator()(const std::pair<NewRecord, size_t>& rcd)
			{
				return (ptr - rcd.first.ptr >= 0) && ((ptr - rcd.first.ptr) % rcd.first.persize == 0) && ((ptr - rcd.first.ptr) / rcd.first.persize < rcd.first.membcount);
			}
			size_t ptr = 0;
		};
	};

public:
	template <typename... Args>
	SignNew(Args &&... args) :m_impl(std::forward<Args>(args)...)
	{
		SignNewPtr(this);
	}

public:
	T& Impl() { return m_impl; }
	const T& Impl() const { return m_impl; }
	operator T() const { return m_impl; }

public:
	bool IsNew() const { return m_is_new; }

public:
	void* operator new(size_t size)
	{
		void* p = ::operator new(size);
		RecordNewPtr(p, size);
		return p;
	}
	void *operator new[](size_t size)
	{
		void* p = ::operator new(size);
		RecordNewPtr(p, size);
		return p;
	}
		void operator delete(void *ptr)
	{
		return ::operator delete(ptr);
	}
	void operator delete[](void *ptr)
	{
		return ::operator delete(ptr);
	}

private:
	static void RecordNewPtr(void* ptr, size_t size)
	{
		size_t sizer = size / sizeof(SignNew<T>) * sizeof(SignNew<T>);
		size_t ptrr = (size_t)ptr; ptrr += size - sizer;
#ifdef THREAD_SAFETY_SIGNNEW
		std::lock_guard<std::mutex> l(m_g_lock);
#endif
		m_g_recods.insert(std::make_pair<NewRecord, size_t>(NewRecord(ptrr, sizeof(SignNew<T>), sizer / sizeof(SignNew<T>)), 0));
	}

	void SignNewPtr(void* ptr)
	{
#ifdef THREAD_SAFETY_SIGNNEW
		std::lock_guard<std::mutex> l(m_g_lock);
#endif
		std::map<NewRecord, size_t>::iterator it = std::find_if(m_g_recods.begin(), m_g_recods.end(), NewRecord::FindOp((size_t)ptr));
		if (it != m_g_recods.end())
		{
			m_is_new = true;
			++(it->second);
			if (it->second == it->first.membcount)
				m_g_recods.erase(it);
		}
	}

private:
	T m_impl;

private:
	bool m_is_new = false;
private:
#ifdef THREAD_SAFETY_SIGNNEW
	static std::mutex m_g_lock;
#endif
	static std::map<NewRecord, size_t> m_g_recods;
};

#ifdef THREAD_SAFETY_SIGNNEW
template <typename T>
std::mutex SignNew<T>::m_g_lock;
#endif

template <typename T>
std::map<typename SignNew<T>::NewRecord, size_t> SignNew<T>::m_g_recods;

template <typename T>
class OnlyNew : public SignNew<T>
{
public:
	template <typename... Args>
	OnlyNew(Args &&... args) :SignNew(std::forward<Args>(args)...)
	{
		assert(IsNew());
	}
};

#endif // _ONLYNEW_H_t

 

方式2，基类继承方式，代码如下：

#ifndef _ONLYNEW_H_
#define _ONLYNEW_H_

#include <algorithm>
#include <map>
#include <assert.h>

#define THREAD_SAFETY_SIGNNEW

#ifdef THREAD_SAFETY_SIGNNEW
#include <mutex>
#endif

template <typename T>
class SignNew : public T
{
private:
	struct NewRecord
	{
		NewRecord(size_t _ptr, size_t _persize, size_t _membcount) :ptr(_ptr), persize(_persize), membcount(_membcount) {}
		size_t ptr = 0;		//Use size_t instead of void *
		size_t persize = 0;
		size_t membcount = 0;
		bool operator<(const NewRecord& that) const
		{
			return ptr < that.ptr;
		}
		struct FindOp
		{
			FindOp(size_t _ptr) : ptr(_ptr) {}
			bool operator()(const std::pair<NewRecord, size_t>& rcd)
			{
				return (ptr - rcd.first.ptr >= 0) && ((ptr - rcd.first.ptr) % rcd.first.persize == 0) && ((ptr - rcd.first.ptr) / rcd.first.persize < rcd.first.membcount);
			}
			size_t ptr = 0;
		};
	};

public:
	template <typename... Args>
	SignNew(Args &&... args) : T(typename std::forward<Args>(args)...)
	{
		SignNewPtr(this);
	}

public:
	bool IsNew() const { return m_is_new; }

public:
	void* operator new(size_t size)
	{
		void* p = ::operator new(size);
		RecordNewPtr(p, size);
		return p;
	}
	void *operator new[](size_t size)
	{
		void* p = ::operator new(size);
		RecordNewPtr(p, size);
		return p;
	}
		void operator delete(void *ptr)
	{
		return ::operator delete(ptr);
	}
	void operator delete[](void *ptr)
	{
		return ::operator delete(ptr);
	}

private:
	static void RecordNewPtr(void* ptr, size_t size)
	{
		size_t sizer = size / sizeof(SignNew<T>) * sizeof(SignNew<T>);
		size_t ptrr = (size_t)ptr; ptrr += size - sizer;
#ifdef THREAD_SAFETY_SIGNNEW
		std::lock_guard<std::mutex> l(m_g_lock);
#endif
		m_g_recods.insert(std::make_pair<NewRecord, size_t>(NewRecord(ptrr, sizeof(SignNew<T>), sizer / sizeof(SignNew<T>)), 0));
	}

	void SignNewPtr(void* ptr)
	{
#ifdef THREAD_SAFETY_SIGNNEW
		std::lock_guard<std::mutex> l(m_g_lock);
#endif
		std::map<NewRecord, size_t>::iterator it = std::find_if(m_g_recods.begin(), m_g_recods.end(), NewRecord::FindOp((size_t)ptr));
		if (it != m_g_recods.end())
		{
			m_is_new = true;
			++(it->second);
			if (it->second == it->first.membcount)
				m_g_recods.erase(it);
		}
	}

private:
	bool m_is_new = false;
private:
#ifdef THREAD_SAFETY_SIGNNEW
	static std::mutex m_g_lock;
#endif
	static std::map<NewRecord, size_t> m_g_recods;
};

#ifdef THREAD_SAFETY_SIGNNEW
template <typename T>
std::mutex SignNew<T>::m_g_lock;
#endif

template <typename T>
std::map<typename SignNew<T>::NewRecord, size_t> SignNew<T>::m_g_recods;

template <typename T>
class OnlyNew : public SignNew<T>
{
public:
	template <typename... Args>
	OnlyNew(Args &&... args) :SignNew<T>(std::forward<Args>(args)...)
	{
		assert(IsNew());
	}
};

#endif // _ONLYNEW_H_

测试例程：

#include "OnlyNew.h"

class CLS
{
public:
	CLS() {}
	CLS(int _1) :m_1(_1) {}
	CLS(double _2) :m_2(_2) {}
	CLS(int _1, double _2) :m_1(_1), m_2(_2) {}
	CLS(const std::string& _3) :m_3(_3) {}
	CLS(int _1, double _2, const std::string& _3) :m_1(_1), m_2(_2), m_3(_3) {}

private:
	int m_1 = 0;
	double m_2 = 1.23;
	std::string m_3 = "abc";
};


void testonlynew()
{
	{
		SignNew<CLS> cls1("Hello");
		SignNew<CLS> cls2[3];
		SignNew<CLS>* cls3 = new SignNew<CLS>(365, 3.1415926, "Hello");
		delete cls3;
		SignNew<CLS>* cls4 = new SignNew<CLS>[4];
		delete[] cls4;
	}
	{
		OnlyNew<CLS> cls5;	//assert
		OnlyNew<CLS>* cls6 = new OnlyNew<CLS>;
		delete cls6;
		OnlyNew<CLS>* cls7 = new OnlyNew<CLS>[4];
		delete[] cls7;
	}
}

 

如果这个模板类只在单线程中使用，则可以不用锁，如果会用到多线程中，编译时请指定THREAD_SAFETY_SIGNNEW

 

两种方式各有优缺点：

方式1：

优点：可以支持pod类型，如int,double

缺点：需要通过Impl()函数获取被包装的真实对象，或者显示使用类型转换运算符，使代码不太美观

方式2：

优点：解决方式1的缺点

缺点：不支持方式1的优点

整合后的代码：通过编译预定义指定实现方式

#ifndef _ONLYNEW_H_
#define _ONLYNEW_H_

#include <algorithm>
#include <map>
#include <assert.h>

#define USE_INHERT
#define THREAD_SAFETY_SIGNNEW

#ifdef THREAD_SAFETY_SIGNNEW
#include <mutex>
#endif

template <typename T>
class SignNew
#ifdef USE_INHERT
	 : public T
#endif
{
private:
	struct NewRecord
	{
		NewRecord(size_t _ptr, size_t _persize, size_t _membcount) :ptr(_ptr), persize(_persize), membcount(_membcount) {}
		size_t ptr = 0;		//Use size_t instead of void *
		size_t persize = 0;
		size_t membcount = 0;
		bool operator<(const NewRecord& that) const
		{
			return ptr < that.ptr;
		}
		struct FindOp
		{
			FindOp(size_t _ptr) : ptr(_ptr) {}
			bool operator()(const std::pair<NewRecord, size_t>& rcd)
			{
				return (ptr - rcd.first.ptr >= 0) && ((ptr - rcd.first.ptr) % rcd.first.persize == 0) && ((ptr - rcd.first.ptr) / rcd.first.persize < rcd.first.membcount);
			}
			size_t ptr = 0;
		};
	};

public:
	template <typename... Args>
	SignNew(Args &&... args)
#ifdef USE_INHERT
 : T(std::forward<Args>(args)...)
#else
 : m_impl(std::forward<Args>(args)...)
#endif
	{
		SignNewPtr(this);
	}

#ifndef USE_INHERT
public:
	T& Impl() { return m_impl; }
	const T& Impl() const { return m_impl; }
	operator T() const { return m_impl; }
#endif

public:
	bool IsNew() const { return m_is_new; }

public:
	void* operator new(size_t size)
	{
		void* p = ::operator new(size);
		RecordNewPtr(p, size);
		return p;
	}
	void *operator new[](size_t size)
	{
		void* p = ::operator new(size);
		RecordNewPtr(p, size);
		return p;
	}
		void operator delete(void *ptr)
	{
		return ::operator delete(ptr);
	}
	void operator delete[](void *ptr)
	{
		return ::operator delete(ptr);
	}

private:
	static void RecordNewPtr(void* ptr, size_t size)
	{
		size_t sizer = size / sizeof(SignNew<T>) * sizeof(SignNew<T>);
		size_t ptrr = (size_t)ptr; ptrr += size - sizer;
#ifdef THREAD_SAFETY_SIGNNEW
		std::lock_guard<std::mutex> l(m_g_lock);
#endif
		m_g_recods.insert(std::make_pair<NewRecord, size_t>(NewRecord(ptrr, sizeof(SignNew<T>), sizer / sizeof(SignNew<T>)), 0));
	}

	void SignNewPtr(void* ptr)
	{
#ifdef THREAD_SAFETY_SIGNNEW
		std::lock_guard<std::mutex> l(m_g_lock);
#endif
		std::map<NewRecord, size_t>::iterator it = std::find_if(m_g_recods.begin(), m_g_recods.end(), NewRecord::FindOp((size_t)ptr));
		if (it != m_g_recods.end())
		{
			m_is_new = true;
			++(it->second);
			if (it->second == it->first.membcount)
				m_g_recods.erase(it);
		}
	}

#ifndef USE_INHERT
private:
	T m_impl;
#endif

private:
	bool m_is_new = false;
private:
#ifdef THREAD_SAFETY_SIGNNEW
	static std::mutex m_g_lock;
#endif
	static std::map<NewRecord, size_t> m_g_recods;
};

#ifdef THREAD_SAFETY_SIGNNEW
template <typename T>
std::mutex SignNew<T>::m_g_lock;
#endif

template <typename T>
std::map<typename SignNew<T>::NewRecord, size_t> SignNew<T>::m_g_recods;

template <typename T>
class OnlyNew : public SignNew<T>
{
public:
	template <typename... Args>
	OnlyNew(Args &&... args) :SignNew<T>(std::forward<Args>(args)...)
	{
		assert(IsNew());
	}
};

#endif // _ONLYNEW_H_

 

后续：

1. 可以用c++11的enable_if或者c++17的constexpr if达到两种方式完全整合，得到最完美的解决方案。

2. N天之后突然想起来，SignNew和OnlyNew都需要对其拷贝，移动，赋值等函数做一些处理。

3. thread safe也可以通过将m_g_recods声明为thread_local来实现。

Coder.Z
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++线程常见包装类实现
站在树顶端设计的男人
10-26 225
C++多线程不如Java那样启动和停止线程那么优雅，如何做到开启线程像Java那样呢？本文将介绍常见的封装C++11线程方式。 线程和其他任务一个样，开启，执行，结束。在CPP当中，执行任务这这一过程就相当于一个回调函数一样，在Java当中有开启线程的方式继承Thread和实现Runnable接口，哈哈哈哈哈哈，一下回到大二听贾老师了属于是，那我们就来实现Java当中的集成Thread这种方式。 定义接口 Start () Stop() Main() 这里的Start()和Stop()函数都是virt
一个简单的C++大数运算包装类（类似高精度）
qq_29322325的博客
10-16 487
C++:一个类高精度的封装
C++沉思录读书笔记（23，24章）- 设计一个针对C接口的C++包装类
不是码农
11-09 2480
真理：使用C接口我们必须遵守它的一些隐藏约定，如果不遵守这些约定的话在程序运行时可能会出现奇怪的情况而导致失败，我们可以使用C++的数据抽象概念对C接口进行改进；对于C++而言，如果对某个类对象的所有单个方法的调用都会让对象置于一种合理的状态，那么对象的状态就能始终保持合理 这个例子针对C语言检查文件系统目录的一个例程集 C语言遍历某个目录下的文件名的代码如下： #include
C++：用类包装算法
henry_23的博客
06-06 364
如何优雅的用类包装算法呢？
C++ 只能new / 只能定义 的方式生成新对象
ustb_atrx的博客
12-27 964
// new_delete.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; // 只能定义，不能new class A{ public: A(){ cout << "A()" << endl; } ~A(){ cout << "~A()" << endl; } private:
java中引用和c++中引用的区别.docx
12-16
试图通过数组或包装类来模拟C++引用的效果是行不通的，因为即使数组元素的改变不会影响原始引用。Java中，基本类型的变量不是对象，它们直接存储在栈上，没有引用的概念，这与C++基本类型的处理方式相同，这是为了...
在C语言中通过模板规避潜在错误
08-01
而在bar()函数中，如果忘记释放通过new分配的内存，将会造成内存泄漏。 为了解决这些问题，我们可以使用模板对定时器管理模块进行重构，如图3所示。新的timer_t类不再需要用户传递回调函数类的实例，而是利用模板...
超级有影响力霸气的Java面试题大全文档
07-18
内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的...
Javaj经典面试.docx
10-29
14. `Integer`是`int`的包装类，用于处理对象。`Integer`可以进行自动装箱和拆箱，但相比`int`，其操作可能稍慢且占用更多内存。 15. `Math.round(11.5)`等于12，`Math.round(-11.5)`等于-11。`round`方法四舍五入...
Java关键字总结珍藏版(48个).doc
09-30
`Byte` 是其对应的包装类，提供了对 `byte` 类型的额外操作。 5. `case`：`case` 用于 `switch` 语句，定义不同情况下的执行路径。每个 `case` 后面跟随一个值，如果 `switch` 表达式匹配该值，则执行相应的代码块...
简单C++线程池包装类源码示例
雪峰流云
10-11 2112
这里给出一个简单的C++线程池包装类,该lei
Java之内存分析和String对象、包装类
乞力马扎罗的雪
05-23 554
Java之内存分析和String对象、包装类 Java中内存分析： 1.  栈(Stack)：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new出来的对象）或者常量池中（字符串常量对象存放在常量池中）。 2.  堆(heap)：存放所有new出来的对象。 3.  常量池(constant pool)：在堆中分配出来的一块存储区域，存储显式的String常量和基
C/C++基本数据类型
weixin_34228617的博客
12-13 99
基本类型 C/C++语言有一组基本类型，对应于计算机的基本存储单元和使用这些单元去保存数据的一些常用方式: 基本数据类型如下: NameDescriptionSize*Range* char Character or small integer. 1byte signed: -128 to 127unsigned: 0 to 255 short int (s...
让类只能用new来创建实例
weixin_30834019的博客
08-03 316
让类只能用new来创建实例 在C++中，类的对象建立分为两种，一种是静态建立，如A a；另一种是动态建立，如A* ptr=new A；这两种方式是有区别的。 1、静态建立类对象：是由编译器为对象在栈空间中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法，直接调用类的构造函数。 2...
用C++\CLI包装普通类
MDLFANS的专栏
10-31 1227
普通类，即不是value class 也不是ref class。是C或者C++的类。这种类必须用new创建，而不是gcnew。所以必须释放。要在cli中使用他们，得找个合适的时机释放他们。见代码： #pragma unmanaged struct __declspec(dllexport) point { double x, y, z; point(double xv, double
包装类详解
lu_lu_n的博客
03-11 380
文章目录包装类包装类的简介包装类的使用包装类的用途装箱与拆箱包装类的缓存问题包装类的常用方法与字符串相关的包装类String类与时间相关的包装类文件 包装类 包装类的简介 Java是一种面向对象的语言，但是不是纯面向对象，Java中的数据类型分为基本数据类型和引用数据类型，其中基本数据类型就不是对象，它不具有属性和方法；Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这些和基本数据...
C++数据类型
wenkun_wang
03-22 885
C++数据类型 记录数据类型的位数和范围 程序结果 类型 所占字节数 最大值 最小值 bool 1 1 0 char 1 signed char 1 unsigned char 1 wchar_t 4 2147483647 -2147483648...
抽象类对象类和对象包装类
香蕉熊的专栏
03-07 708
抽象类继承层越高，类就更通用并且更抽象，有些层中的祖先类非常通用，更适于作为其他类的框架，而不适于作为具体类，来使用其特定实例。比如，假设电子消息系统包括电子邮件，传真和语音邮件，它必须能处理文本消息，传真消息和语音消息。 按照oop原则，该程序应由文本消息类(textMessage),语音消息类(voiceMessage)和传真消息类(faxMessage)。而信箱需要存储和混合这些消息，因此还
学习C++ 数据类型 有哪些
Wis57的博客
03-27 408
long int 8 个字节，int 都是 4 个字节，早期的 C 编译器定义了 long int 占用 4 个字节，int 占用 2 个字节，新版的 C/C++ 标准兼容了早期的这一设定。默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。例如，在下面的枚举中，所谓"枚举"是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。变量保留的是它所存储的值的内存位置。重新解释转换将一个数据类型的值重新解释为另一个数据类型的值，通常用于在不同的数据类型之间进行转换。
C++类实例化对象的方式
最新发布
06-06
C++类实例化对象的方式是使用 `new` 操作符创建一个对象，并返回一个指向该对象的指针。例如： ``` class MyClass { public: MyClass(int arg) { this->arg = arg; } private: int arg; }; MyClass* obj = new...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值