C++实现Python变量续

最新推荐文章于 2023-07-30 13:18:53 发布
最新推荐文章于 2023-07-30 13:18:53 发布
阅读量1.3k 收藏 3
点赞数
分类专栏： C/C++ 文章标签： C++智能指针值语义 C++实现python变量 C++内存管理 改造C++变量 C++模板使用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liaoyoujinb/article/details/16344727
版权

C++实现Python变量续


        想问题总是不够全面，一觉醒来突然发现昨天的实现语义不明朗，有点小问题，本来是想实现值语义的，就像a=100,b = a,b = 101.那么b是不会影响a的值得，如果影响了，那就是指针语义了。昨天的设计就是指针语义。

        在C/C++中我们一个变量一般会跟固定的内存邦定，在运行期是不会改变的，只有指针会改变。那么我们会认为指针指向的是不同的变量，其实这只不过是一个定势思维。何为变量？这其实是一种概念的东西在C/C++中变量意味着一段固定地址空间的标识。然而在Python中所谓的变量其实就是“指针“（个人理解），例如a = 100.其实就是指针a指向100这个常量，我们关心的只是标识符a的值，但并不关心a存储在那段空间。当改变a的值时，其实只是给它换一个存储空间罢了，如a = 1000.Python所做的并不是改变a所在地址的值，而是给a分配一段新的内存，然后存入1000。这实际上非常合理，我们使用变量的目的是用于计算，计算得核心内容是值，而不是地址。我们关心的只是a和a的值，就像公司只关心你这个人和你的价值，至于你住哪，关我鸟事。C/C++之所以危险就是把计算问题和地址扯上了关系。可能C/C++比较专一吧，认准了a住在1号房间，就死也不放，哪天1号房间住进了b，你还误以为是a,可偏偏C/C++还允许这么2的事情发生。Python在这方面就聪明多了，Python变量比较洒脱，四海为家。一个变量并不代表一段固定的内存。在Python程序中被分配的空间都视为常量，不允许改变。当变量a更新了那你要么找到与你的值对应的空间归队，要么新申请一段内存吧。打个比方，程序中分别分配了如下空间：

                 空间     0x01      0x02         0x03       0x04       0x05        0x06

                 语义     1年级   2年级       3年级     4年级    5年级     6年级

 

                  a= 1 年级，                那么a指向0x01,那么你就去1年级读书。

                  a = a+1 = 2 年级，      那么a指向0x02,那么你就去2年级读书。

        这种方式比较节约内存，不会出现重复的值。但是需要查表的时间，以时间来换空间，对于现代计算机来说，比较好的做法是新分配一段内存空间来保存新值。但这也有一个问题，那就是这样做的后果是频繁的malloc/free,new/delete那么是否可以解决这一问题呢？有，我们可以借鉴STL的内存分配策略，设置一个内存分配表，和一个内存空闲表，当分配内存失败时，释放掉一些其他空闲表的空间。（这里的分配表是类型分配表）。这样就不需要频繁的释放资源了。

         频繁释放资源解释：

                                                                                  a = 100;    0x01

                                                                                  a = 101;    0x02

        a=100时，0x01的引用计数是1,当a = 101时，0x01引用计数为0，被销毁，分配0x02。

        除了这种处理方案，我们也可以将其改造为智能指针，这就是纯指针语义。但我们的意愿是在程序代码中不允许常规指针的出现。那么就需要有一个分配器，其返回的是智能指针。也就是这种方案指针和分配过程并非邦定。其次，我们可以实现表象是值，但实际是指针语义的功能。好吧下面我们就以dint为例一一实现这三种设计思路（实现的是非线程安全的版本）：

 

一、    值语义dint


1.定义


        所谓值语义，就是当我们在使用dint时，表现出来的是值，我们所有的操作都是改变自身的值，而不影响任何其他变量的值，简单来讲， a = b,a = 100,那么b不会跟着改变。这样a = b,获得的是b的值，本意没有抢占b地址的意思，虽然实际上我暂时租用了一会儿。实际上在这种语义上地址不属于任何变量，每个变量都是暂住着。无论是a,b,c关心的只是地址中的数据是否是我想要的，但是并不关系这个数据存在哪里。也没兴趣改变这个地址里的数据。你如果不是我想要的，我就他处找寻去。也即C/C++本身是以地址为中心的。而该语义是以数据为中心的，某段空间里的值在构造期决定，之后就不允许改变。

 

2.实现


1．频繁释放资源版本


//Version0.1
#include<iostream>
using namespace std;
template<class T>
struct dtype//none thread security
{
	int count;
	T  data;
	dtype():count(1){}
	dtype(const T& t):count(1),data(t){}
};

class  dint{
public:
   dint()
	{
		p = new dtype<int>();
	}
	dint(const int& i)
	{
		p = new dtype<int>(i);
	}
	dint(const dint& d)
	{	
		p = d.p;
		p->count++;
	}
	~dint()
	{
		p->count--;
		if(0 == p->count)
		{
			destory();
		}
	}
	dint& operator=(dint& d)
	{
		if(this != &d)
		{
			int i = --p->count;
			if(0 == i)destory();
			p = d.p;
			p->count++;
		}
		return *this;
	}
	dint& operator=(const int& d)
	{
		int i = --p->count;
		if(0 == i)destory();
		p = new dtype<int>(d);
		return *this;
	}
	operator int&()
	{
		return p->data;
	}
	operator int&() const//convert the const dint
	{
		return p->data;
	}
	dint& operator++()
	{
		int data = p->data;
		int i = --p->count;
		if(0 == i)destory();
		p = new dtype<int>(data+1);
		return *this;
	}
	dint operator++(int)
	{
		
		dint tmp(*this);
		int data = p->data;
		int i = --p->count;
		if(0 == i)destory();
		p = new dtype<int>(data+1);
		return tmp;
	}
	dint& operator--()
	{
		int data = p->data;
		int i = --p->count;
		if(0 == i)destory();
		p = new dtype<int>(data-1);
		return *this;
	}
	dint operator--(int)
	{
		
		dint tmp(*this);
		int data = p->data;
		int i = --p->count;
		if(0 == i)destory();
		p = new dtype<int>(data-1);
		return tmp;
	}
	void destory()
	{
		cout<<"really delete the p."<<endl;
		delete p;
	}
private:
	dtype<int>* p; //p is nerver be NULL,it is allways bind to a int.
};

2.  空闲表版本


//Version0.2
#include<iostream>
using namespace std;
template<class T>
struct dtype//none thread security
{
	int count;
	T  data;
	dtype():count(1){}
	dtype(const T& t):count(1),data(t){}
};

template<class T>
struct node{
	dtype<T> *p;
	struct node* next;
	node():next(NULL)
	{
		p = new dtype<T>();
	}
	~node()
	{
		delete p;
	}
	void set(const T& t)
	{
		p->data = t;
	}
	void AddUseCount()
	{
		p->count++;
	}
	void SubUseCount()
	{
		p->count--;
	}
	bool IsCount0()
	{
		return !(p->count);
	}
	T& GetData()
	{
		return p->data;
	}
};

template<class T>
class Alloctor{
public:
	Alloctor():ListHead(NULL),ListTail(NULL),len(0)
	{
		Malloc(10);
	}
	~Alloctor()
	{
		while(len)
		{
			cout<<"~Alloctor()"<<endl;
			delete pop();
		}
	}
	node<T>* Construct()
	{
		if(ListHead == NULL && ListTail == NULL)//can be delete
		{
			Malloc(10);
		}
		else if(ListHead == ListTail)
		{
			Malloc(10);
		}
		//get the element on head.
		return pop();
	}
	
	node<T>* Construct(const T& t)
	{
		if(ListHead == NULL && ListTail == NULL)//can be delete
		{
			Malloc(10);
		}
		else if(ListHead == ListTail)
		{
			Malloc(10);
		}
		//get the element on head.
		node<T>* n = pop();
		n->set(t);
		return n;
	}
	bool destory(node<T>* n)
	{
		if(len < 100)                           //add to the tail;
		{
			cout<<"push to the tail of freeList."<<endl;
			push(n);
		}
		else{                                   //really delete.
			cout<<"really delete the block."<<endl;
			delete n;
			for(int i = 0;i < 50;i++)
			{
				delete pop();
			}
		}
	}
protected:
	void Malloc(int size)
	{
		
		while(size)
		{
			node<T> *n = new node<T>();
			push(n);
			size--;
		}
	}
	node<T>* pop()
	{
		node<T> * n = ListHead;
		ListHead = ListHead->next;
		len--;
		return n;
	}
	bool push(node<T>* n)
	{
		if(ListHead == NULL && ListTail == NULL)	
		{
			ListHead = ListTail = n;	
		}
		else{
			ListTail->next = n;
			ListTail = n;
		}
		len++;
	}
private:
	node<T>* ListHead;
	node<T>* ListTail;
	int len;
};



class  dint{
public:
   dint()
	{
		block = alloc.Construct();
	}
	dint(const int& i)
	{
		block = alloc.Construct(i);
	}
	dint(const dint& d)
	{	
		block = d.block;
		block->AddUseCount();
	}
	~dint()
	{
		block->SubUseCount();
		if(true == block->IsCount0())
		{
			destory();
		}
	}
	dint& operator=(dint& d)
	{
		if(this != &d)
		{
			block->SubUseCount();
			if(true == block->IsCount0())destory();
			block = d.block;
			block->AddUseCount();
		}
		return *this;
	}
	dint& operator=(const int& d)
	{
		block->SubUseCount();
		if(true == block->IsCount0())destory();
		block = alloc.Construct(d);
		return *this;
	}
	operator int&()
	{
		return block->GetData();
	}
	operator int&() const//convert the const dint
	{
		return block->GetData();
	}
	dint& operator++()
	{
		int data = block->GetData();
		block->SubUseCount();
		if(true == block->IsCount0())destory();
		block = alloc.Construct(data+1);
		return *this;
	}
	dint operator++(int)
	{
		
		dint tmp(*this);
		int data = block->GetData();
		block->SubUseCount();
		if(true == block->IsCount0())destory();
		block = alloc.Construct(data+1);
		return tmp;
	}
	dint& operator--()
	{
		int data = block->GetData();
		block->SubUseCount();
		if(true == block->IsCount0())destory();
		block = alloc.Construct(data-1);
		return *this;
	}
	dint operator--(int)
	{
		
		dint tmp(*this);
		int data = block->GetData();
		block->SubUseCount();
		if(true == block->IsCount0())destory();
		block = alloc.Construct(data-1);
		return tmp;
	}
	void destory()
	{
		cout<<"ask alloc for delete."<<endl;
		alloc.destory(block);
	}
private:
	node<int>* block;	//p is nerver be NULL,it is allways bind to a int.
	static Alloctor<int> alloc;
};
Alloctor<int> dint::alloc = Alloctor<int>();


3.通用版本（含空闲表）


//Version0.3
#include<iostream>
#include<vector>
#include<cstdlib>
#include<stdio.h>
using namespace std;
template<class T>
struct dtype//none thread security
{
	int count;
	T  data;
	dtype():count(1){}
	dtype(const T& t):count(1),data(t){}
};

template<class T>
struct node{
	dtype<T> *p;
	struct node* next;
	node():next(NULL)
	{
		p = new dtype<T>();
	}
	~node()
	{
		delete p;
	}
	void set(const T& t)
	{
		p->data = t;
	}
	void AddUseCount()
	{
		p->count++;
	}
	void SubUseCount()
	{
		p->count--;
	}
	bool IsCount0()
	{
		return !(p->count);
	}
	T& GetData()
	{
		return p->data;
	}
};

template<class T>
class Alloctor{
public:
	Alloctor():ListHead(NULL),ListTail(NULL),len(0)
	{
		Malloc(10);
	}
	~Alloctor()
	{
		while(len)
		{
			cout<<"~Alloctor()"<<endl;
			delete pop();
		}
	}
	node<T>* Construct()
	{
		if(ListHead == NULL && ListTail == NULL)//can be delete
		{
			Malloc(10);
		}
		else if(ListHead == ListTail)
		{
			Malloc(10);
		}
		//get the element on head.
		return pop();
	}
	
	node<T>* Construct(const T& t)
	{
		if(ListHead == NULL && ListTail == NULL)//can be delete
		{
			Malloc(10);
		}
		else if(ListHead == ListTail)
		{
			Malloc(10);
		}
		//get the element on head.
		node<T>* n = pop();
		n->set(t);
		return n;
	}
	bool destory(node<T>* n)
	{
		if(len < 100)                           //add to the tail;
		{
			cout<<"push to the tail of freeList."<<endl;
			push(n);
		}
		else{                                   //really delete.
			cout<<"really delete the block."<<endl;
			delete n;
			for(int i = 0;i < 50;i++)
			{
				delete pop();
			}
		}
	}
protected:
	void Malloc(int size)
	{
		
		while(size)
		{
			node<T> *n = new node<T>();
			push(n);
			size--;
		}
	}
	node<T>* pop()
	{
		node<T> * n = ListHead;
		ListHead = ListHead->next;
		len--;
		return n;
	}
	bool push(node<T>* n)
	{
		if(ListHead == NULL && ListTail == NULL)	
		{
			ListHead = ListTail = n;	
		}
		else{
			ListTail->next = n;
			ListTail = n;
		}
		len++;
	}
private:
	node<T>* ListHead;
	node<T>* ListTail;
	int len;
};


template<class T>
class  PythonC{
public:
	typedef T  value_type;
public:
   PythonC()
	{
		block = alloc.Construct();
	}
	PythonC(const T& i)
	{
		block = alloc.Construct(i);
	}
	PythonC(const PythonC& d)
	{	
		block = d.block;
		block->AddUseCount();
	}
	~PythonC()
	{
		block->SubUseCount();
		if(true == block->IsCount0())
		{
			destory();
		}
	}
	PythonC& operator=(PythonC& d)
	{
		if(this != &d)
		{
			block->SubUseCount();
			if(true == block->IsCount0())destory();
			block = d.block;
			block->AddUseCount();
		}
		return *this;
	}
	PythonC& operator=(const T& d)
	{
		block->SubUseCount();
		if(true == block->IsCount0())destory();
		block = alloc.Construct(d);
		return *this;
	}
	operator T&()
	{
		return block->GetData();
	}
	operator const T&() const//convert the const PythonC
	{
		return block->GetData();
	}
	T& operator*()
	{
		return block->GetData();
	}
	const T& operator*() const
	{
		return block->GetData();
	}
	T& self()
	{
		return block->GetData();
	}
	const T& self() const
	{
		return block->GetData();
	}
	friend ostream& operator<<(ostream& os, const PythonC<T>& f)
	{ 
		cout<<(f.block)->GetData();
	}
protected:
	PythonC& operator++();
	PythonC operator++(int);
	PythonC& operator--();
	PythonC operator--(int);
	void destory()
	{
		cout<<"ask alloc for delete."<<endl;
		alloc.destory(block);
	}
private:
	node<T>* block;	//p is nerver be NULL,it is allways bind to a int.
	static Alloctor<T> alloc;
};
template<class T> Alloctor<T> PythonC<T>::alloc = Alloctor<T>();

template <class T>
typename T::value_type& U(T& t)
{
	cout<<"U Function."<<endl;
	return t.self();
}
template <class T>
const typename T::value_type& U(const T& t)
{
	cout<<"d U Function."<<endl;
	return t.self();
}


3.测试


1.Version0.1测试

void test(dint& i)//covert
{
	i = 9999;
}
void test2(dint h)
{
	h = 888;
}

int main()
{
	dint c;
	c = 100;
	dint a = c;
	a = a*a;
	cout<<c<<endl;
	cout<<a<<endl;
	test2(a);
	cout<<a<<endl;
	test(a);	
	cout<<a<<endl;
	
	cout<<a++<<endl;
	cout<<++a<<endl;	
}

2.Version0.2测试

void test(dint& i)//covert
{
	i = 9999;
}
void test2(dint h)
{
	h = 888;
}

int main()
{
	dint c;
	c = 100;
	dint a = c;
	a = a*a;
	cout<<c<<endl;
	cout<<a<<endl;
	test2(a);
	cout<<a<<endl;
	test(a);	
	cout<<a<<endl;
	
	cout<<a++<<endl;
	cout<<++a<<endl;
}


3.Version0.3测试

class String{
public:
	typedef PythonC<char>  value_type;
public:
	String(){}
	void push(const value_type& d)
	{
		str.push_back(d);
	}
	friend ostream& operator<<(ostream& os, const String& f)
	{ 
		vector<value_type>::const_iterator iter = (f.str).begin();
		vector<value_type>::const_iterator End = (f.str).end();
		os<<End-iter<<endl;
		while(iter != End)
		{
			os<<*iter++;
		}
		return os;
	}
	
private:
	vector<value_type> str;
};


int main()
{
	PythonC<char> c = 'A';
	cout<<c<<endl;
	String s;
	for(int i = 0;i < 10;i++)
	{
		s.push(c);
	}
	cout<<s<<endl;	
	String l = s;
	cout<<l<<endl;	
	PythonC<char> pc = 'B';
	l.push(pc);
	cout<<s<<endl;	
	cout<<l<<endl;	
}

 

4.总结


        该语义下，传递函数参数和C/C++相同，传递标量会产生临时变量，不会改变传入变量的值。传递引用则不会产生临时变量，会改变传入变量的值。其实改变值同时也伴随着新的空间分配。与定义部分无冲突。但是基于实现的细节，我们必须禁用++，--操作符，或者重载。我们给出的是重载版本，但在通用模板中由于不是所有类型都有++,--操作，所以禁用这两个操作符。事实上我们要把所有操作地址的操作都重载掉。const函数版本是非常有必要的，否则常量就不能正常工作了。这里说的通用版本只是针对内置类型，因为其他类类型及STL的容器类型有许多操作会改变内存，而我们的宗旨是不允许改变内存。然而实现统一的禁用所有改变内存的操作显得不现实。所以目前仅仅实现内置类型的通用版本。虽然这里通用版本实现了“*“操作符，但是由于是值语义所以不建议使用。推荐：self(),U()。实际上内置类型可以隐式类型转换，不需要这些操作亦可。

        实现类类型的版本唯一的办法就是所有类的实现都基于我们封装的内置类型。



二、    指针语义dint

 

1.   定义


        所谓指针语义就是改变变量的值实际是改变某个特定内存空间的值，此时dint不代表一个实际的数据，而是表示指向某个数据的智能指针，如dint a;其实a本质上是一个NULL指针。它与内存的分配完全是0耦合的。由于不建议程序员直接使用常规指针（不允许智能指针指向非动态分配的内存空间）。所以需要一个构造器C。dint a = C<dint>(); dint b = a;当改变b时a也会跟着改变的。这就是指针语义，a,b被绑定到同一段内存空间。对a,b的操作意味着对这段内存空间的操作。

 

2.   实现


1.   无空闲表版本

//Version0.4
#include<iostream>
using namespace std;
template<class T>
struct dtype//none thread security
{
	int count;
	T  data;
	dtype():count(1){}
	dtype(const T& t):count(1),data(t){}
};

template<class T>
class Alloctor{
public:
	Alloctor(){}
	~Alloctor(){}
	dtype<T>* Construct()
	{
		return new dtype<T>();
	}
	
	dtype<T>* Construct(const T& t)
	{
		return new dtype<T>(t);
	}
};
static Alloctor<int> alloc = Alloctor<int>();
dtype<int>* C()
{
	return alloc.Construct();
}
dtype<int>* C(const int& i)
{
	return alloc.Construct(i);
}

class  dint{
public:
   dint():block(NULL){}
	dint(dtype<int>* p):block(p){}
	dint(const dint& d)
	{	
		block = d.block;
		block->count++;
	}
	~dint()
	{
		block->count--;
		if(0 == block->count)
		{
			destory();
		}
	}
	dint& operator=(dint& d)
	{
		if(this != &d)
		{
			block->count--;
			if(0 == block->count)destory();
			block = d.block;
			block->count++;
		}
		return *this;
	}
	dint& operator=(dtype<int>* p)
	{
		block->count--;
		if(0 == block->count)destory();
		block = p;
		block->count++;
		return *this;
	}
	int& operator*()
	{
		return block->data;
	}
	const int& operator*() const
	{
		return block->data;
	}
	int* operator->() //can't use in int.
	{
		return &block->data;
	}
	const int* operator->() const
	{
		return &block->data;
	}
	void destory()
	{
		cout<<"really delete the p."<<endl;
		delete block;
	}
private:
	dtype<int>* block;	//p is nerver be NULL,it is allways bind to a int.
};


2.   空闲表版本

//Version0.5
#include<iostream>
using namespace std;
template<class T>
struct dtype//none thread security
{
	int count;
	T  data;
	dtype():count(1){}
	dtype(const T& t):count(1),data(t){}
};

template<class T>
struct node{
	dtype<T> *p;
	struct node* next;
	node():next(NULL)
	{
		p = new dtype<T>();
	}
	~node()
	{
		delete p;
	}
	void set(const T& t)
	{
		p->data = t;
	}
	void AddUseCount()
	{
		p->count++;
	}
	void SubUseCount()
	{
		p->count--;
	}
	bool IsCount0()
	{
		return !(p->count);
	}
	T& GetData()
	{
		return p->data;
	}
};

template<class T>
class Alloctor{
public:
	Alloctor():ListHead(NULL),ListTail(NULL),len(0)
	{
		Malloc(10);
	}
	~Alloctor()
	{
		while(len)
		{
			cout<<"~Alloctor()"<<endl;
			delete pop();
		}
	}
	node<T>* Construct()
	{
		if(ListHead == NULL && ListTail == NULL)//can be delete
		{
			Malloc(10);
		}
		else if(ListHead == ListTail)
		{
			Malloc(10);
		}
		//get the element on head.
		return pop();
	}
	
	node<T>* Construct(const T& t)
	{
		if(ListHead == NULL && ListTail == NULL)//can be delete
		{
			Malloc(10);
		}
		else if(ListHead == ListTail)
		{
			Malloc(10);
		}
		//get the element on head.
		node<T>* n = pop();
		n->set(t);
		return n;
	}
	bool destory(node<T>* n)
	{
		if(len < 100)                           //add to the tail;
		{
			cout<<"push to the tail of freeList."<<endl;
			push(n);
		}
		else{                                   //really delete.
			cout<<"really delete the block."<<endl;
			delete n;
			for(int i = 0;i < 50;i++)
			{
				delete pop();
			}
		}
	}
protected:
	void Malloc(int size)
	{
		
		while(size)
		{
			node<T> *n = new node<T>();
			push(n);
			size--;
		}
	}
	node<T>* pop()
	{
		node<T> * n = ListHead;
		ListHead = ListHead->next;
		len--;
		return n;
	}
	bool push(node<T>* n)
	{
		if(ListHead == NULL && ListTail == NULL)	
		{
			ListHead = ListTail = n;	
		}
		else{
			ListTail->next = n;
			ListTail = n;
		}
		len++;
	}
private:
	node<T>* ListHead;
	node<T>* ListTail;
	int len;
};
static Alloctor<int> alloc = Alloctor<int>();
node<int>* C()
{
	return alloc.Construct();
}
node<int>* C(const int& i)
{
	return alloc.Construct(i);
}

class  dint{
public:
   dint():block(NULL){}
	dint(node<int>* p):block(p){}
	dint(const dint& d)
	{	
		block = d.block;
		block->AddUseCount();
	}
	~dint()
	{
		block->SubUseCount();
		if(true == block->IsCount0())
		{
			destory();
		}
	}
	dint& operator=(dint& d)
	{
		if(this != &d)
		{
			block->SubUseCount();
			if(true == block->IsCount0())destory();
			block = d.block;
			block->AddUseCount();
		}
		return *this;
	}
	dint& operator=(node<int>* p)
	{
		block->SubUseCount();
		if(true == block->IsCount0())destory();
		block = p;
		block->AddUseCount();
		return *this;
	}
	int& operator*()
	{
		return block->GetData();
	}
	const int& operator*() const
	{
		return block->GetData();
	}
	void destory()
	{
		cout<<"ask alloc for delete."<<endl;
		alloc.destory(block);
	}
private:
	node<int>* block;	//p is nerver be NULL,it is allways bind to a int.
};


3.通用版（含空闲表）

// Version0.6
#include<iostream>
#include<vector>
using namespace std;
template<class T>
struct dtype//none thread security
{
	int count;
	T  data;
	dtype():count(1){}
	dtype(const T& t):count(1),data(t){}
};

template<class T>
struct node{
	dtype<T> *p;
	struct node* next;
	node():next(NULL)
	{
		p = new dtype<T>();
	}
	~node()
	{
		delete p;
	}
	void set(const T& t)
	{
		p->data = t;
	}
	void AddUseCount()
	{
		p->count++;
	}
	void SubUseCount()
	{
		p->count--;
	}
	bool IsCount0()
	{
		return !(p->count);
	}
	T& GetData()
	{
		return p->data;
	}
};

template<class T>
class Alloctor{
public:
	Alloctor():ListHead(NULL),ListTail(NULL),len(0)
	{
		Malloc(10);
	}
	~Alloctor()
	{
		while(len)
		{
			cout<<"~Alloctor()"<<endl;
			delete pop();
		}
	}
	node<T>* Construct()
	{
		if(ListHead == NULL && ListTail == NULL)//can be delete
		{
			Malloc(10);
		}
		else if(ListHead == ListTail)
		{
			Malloc(10);
		}
		//get the element on head.
		return pop();
	}
	
	node<T>* Construct(const T& t)
	{
		if(ListHead == NULL && ListTail == NULL)//can be delete
		{
			Malloc(10);
		}
		else if(ListHead == ListTail)
		{
			Malloc(10);
		}
		//get the element on head.
		node<T>* n = pop();
		n->set(t);
		return n;
	}
	bool destory(node<T>* n)
	{
		if(len < 100)                           //add to the tail;
		{
			cout<<"push to the tail of freeList."<<endl;
			push(n);
		}
		else{                                   //really delete.
			cout<<"really delete the block."<<endl;
			delete n;
			for(int i = 0;i < 50;i++)
			{
				delete pop();
			}
		}
	}
protected:
	void Malloc(int size)
	{
		
		while(size)
		{
			node<T> *n = new node<T>();
			push(n);
			size--;
		}
	}
	node<T>* pop()
	{
		node<T> * n = ListHead;
		ListHead = ListHead->next;
		len--;
		return n;
	}
	bool push(node<T>* n)
	{
		if(ListHead == NULL && ListTail == NULL)	
		{
			ListHead = ListTail = n;	
		}
		else{
			ListTail->next = n;
			ListTail = n;
		}
		len++;
	}
private:
	node<T>* ListHead;
	node<T>* ListTail;
	int len;
};

template<class T>
class MemManager{
public:
	static Alloctor<T> alloc;
};
template<class T> Alloctor<T> MemManager<T>::alloc = Alloctor<T>();


template<class T>
class  Obj_ptr{
public:
	typedef T  value_type;
public:
   Obj_ptr():block(NULL){}
	Obj_ptr(node<T>* p)
	{
		block = p;
	}
	Obj_ptr(const Obj_ptr& d)
	{	
		block = d.block;
		block->AddUseCount();
	}
	~Obj_ptr()
	{
		block->SubUseCount();
		if(true == block->IsCount0())
		{
			destory();
		}
	}
	Obj_ptr& operator=(Obj_ptr& d)
	{
		if(this != &d)
		{
			block->SubUseCount();
			if(true == block->IsCount0())destory();
			block = d.block;
			block->AddUseCount();
		}
		return *this;
	}
	T& operator*()
	{
		return block->GetData();
	}
	const T& operator*() const
	{
		return block->GetData();
	}
	T* operator->()
	{
		return &(block->GetData());
	}
	const T* operator->() const
	{
		return &(block->GetData());
	}
protected:
	void destory()
	{
		cout<<"ask alloc for delete."<<endl;
		MemManager<T>::alloc.destory(block);
	}
private:
	node<T>* block;	//p is nerver be NULL,it is allways bind to a int.
};

template<class T>
node<T>* C()
{
	return MemManager<T>::alloc.Construct();
}

template<class T>
node<T>* C(const T& i)
{
	return MemManager<T>::alloc.Construct(i);
}


3.   测试

1.Version0.4测试

void test(dint& i)//covert
{
	*i = 9999;
}
void test2(dint h)
{
	*h = 888;
}
int main()
{
	dint c = C(10);
	dint b = c;
	dint a = c;
	
	*a = 100;
	cout<<*a<<" "<<*b<<" "<<*c<<endl;	
	*a = *a + 33;
	cout<<*a<<" "<<*b<<" "<<*c<<endl;	
	const dint d = c;
	cout<<*d<<endl;
}

2.Version0.5测试

//Version0.5
void test(dint& i)//covert
{
	*i = 9999;
}
void test2(dint h)
{
	*h = 888;
}
int main()
{
	dint c = C(10);
	dint b = c;
	dint a = c;
	
	*a = 100;
	cout<<*a<<" "<<*b<<" "<<*c<<endl;	
	*a = *a + 33;
	cout<<*a<<" "<<*b<<" "<<*c<<endl;	
	const dint d = c;
	cout<<*d<<endl;
}

3.Version0.6测试

//Version0.6
int main()
{
	typedef vector<int>  Type;
	Obj_ptr<Type> s = C<Type>();
	s->push_back(100);
	cout<<s->empty()<<endl;
	cout<<s->size()<<endl;
}

4.   总结

         在该语义下，dint完全是一个智能指针，它只能通过"*","->"操作符来访问对象。引用计数和对象绑定虽然带来了空间上的消耗，但是节省了管理内存的时间。


三、    值-指针语义dint

 

1.   定义


        所谓值-指针语义：就是可以以对象的形式来使用指针，彻底抛弃“*“，“->“操作符。但实际上它仍然是指针语义。也需要配合Alloctor来使用，程序员接触到的构造器是C（也可以定义为New/Malloc）。

 

2.   实现


        这里就只给出通用版本了的实现了，分配器其实都是相同的：

1.通用版（含空闲列表）     

//Version0.7
#include<iostream>
#include<vector>
using namespace std;
template<class T>
struct dtype//none thread security
{
	int count;
	T  data;
	dtype():count(1){}
	dtype(const T& t):count(1),data(t){}
};

template<class T>
struct node{
	dtype<T> *p;
	struct node* next;
	node():next(NULL)
	{
		p = new dtype<T>();
	}
	~node()
	{
		delete p;
	}
	void set(const T& t)
	{
		p->data = t;
	}
	void AddUseCount()
	{
		p->count++;
	}
	void SubUseCount()
	{
		p->count--;
	}
	bool IsCount0()
	{
		return !(p->count);
	}
	T& GetData()
	{
		return p->data;
	}
};

template<class T>
class Alloctor{
public:
	Alloctor():ListHead(NULL),ListTail(NULL),len(0)
	{
		Malloc(10);
	}
	~Alloctor()
	{
		while(len)
		{
			cout<<"~Alloctor()"<<endl;
			delete pop();
		}
	}
	node<T>* Construct()
	{
		if(ListHead == NULL && ListTail == NULL)//can be delete
		{
			Malloc(10);
		}
		else if(ListHead == ListTail)
		{
			Malloc(10);
		}
		//get the element on head.
		return pop();
	}
	
	node<T>* Construct(const T& t)
	{
		if(ListHead == NULL && ListTail == NULL)//can be delete
		{
			Malloc(10);
		}
		else if(ListHead == ListTail)
		{
			Malloc(10);
		}
		//get the element on head.
		node<T>* n = pop();
		n->set(t);
		return n;
	}
	bool destory(node<T>* n)
	{
		if(len < 100)                           //add to the tail;
		{
			cout<<"push to the tail of freeList."<<endl;
			push(n);
		}
		else{                                   //really delete.
			cout<<"really delete the block."<<endl;
			delete n;
			for(int i = 0;i < 50;i++)
			{
				delete pop();
			}
		}
	}
protected:
	void Malloc(int size)
	{
		
		while(size)
		{
			node<T> *n = new node<T>();
			push(n);
			size--;
		}
	}
	node<T>* pop()
	{
		node<T> * n = ListHead;
		ListHead = ListHead->next;
		len--;
		return n;
	}
	bool push(node<T>* n)
	{
		if(ListHead == NULL && ListTail == NULL)	
		{
			ListHead = ListTail = n;	
		}
		else{
			ListTail->next = n;
			ListTail = n;
		}
		len++;
	}
private:
	node<T>* ListHead;
	node<T>* ListTail;
	int len;
};

template<class T>
class MemManager{
public:
	static Alloctor<T> alloc;
};
template<class T> Alloctor<T> MemManager<T>::alloc = Alloctor<T>();


template<class T>
class  Obj_ptr{
public:
	typedef T  value_type;
public:
   Obj_ptr():block(NULL){}
	Obj_ptr(node<T>* p)
	{
		block = p;
	}
	Obj_ptr(const Obj_ptr& d)
	{	
		block = d.block;
		block->AddUseCount();
	}
	~Obj_ptr()
	{
		block->SubUseCount();
		if(true == block->IsCount0())
		{
			destory();
		}
	}
	Obj_ptr& operator=(Obj_ptr& d)
	{
		if(this != &d)
		{
			block->SubUseCount();
			if(true == block->IsCount0())destory();
			block = d.block;
			block->AddUseCount();
		}
		return *this;
	}
	operator T&()
	{
		return block->GetData();
	}
	operator const T&() const//convert the const Obj_ptr
	{
		return block->GetData();
	}
	T& self()
	{
		return block->GetData();
	}
	const T& self() const
	{
		return block->GetData();
	}
protected:
	void destory()
	{
		cout<<"ask alloc for delete."<<endl;
		MemManager<T>::alloc.destory(block);
	}
private:
	node<T>* block;	//p is nerver be NULL,it is allways bind to a int.
};

template <class T>
typename T::value_type& U(T& t)
{
	cout<<"U Function."<<endl;
	return t.self();
}
template <class T>
const typename T::value_type& U(const T& t)
{
	cout<<"d U Function."<<endl;
	return t.self();
}


template<class T>
node<T>* C()
{
	return MemManager<T>::alloc.Construct();
}

template<class T>
node<T>* C(const T& i)
{
	return MemManager<T>::alloc.Construct(i);
}


3.测试

int main()
{
	typedef vector<int>  Type;
	Obj_ptr<Type> s = C<Type>();
	U(s).push_back(100);
	cout<<U(s).empty()<<endl;
	cout<<U(s).size()<<endl;
}


4.总结


         在该语义下我们彻底的摆脱了"*","->"操作符，可以像使用普通对象一样使用指针了，但是我们必须时刻保持指针这个意识，改变某一个值将引起“蝴蝶效应”。

 
东大学子
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python实现类的静态变量用法实例
09-22
在Python中，没有像Java或C++那样的`static`关键字来声明静态变量。但是，我们可以通过以下两种方式实现类似的功能： 1. 使用类属性（Class Attributes）：直接在类定义内部设置变量，无需通过任何方法。例如： ``...
使用C++调用Python代码的方法详解
08-25
在使用C++调用Python代码之前，需要首先安装Python环境，并将Python添加到环境变量中。在VS中，需要配置项目属性，包括包含目录和库目录。包含目录为Python安装路径下的include文件夹，而库目录为Python安装路径下的...
C++实现Python变量
liaoyoujinb的专栏
11-14 1526
C++实现Python变量         仔细想想，其实所有分配在栈和静态存储区的存储空间都是由一个变量来标识，这是由系统自己管理的内存空间，而堆上分配的空间在每次运行期都是不一样的，也就是不是编译期决定的，所以只能用指针来标识。那么我们是否可以将这种指针标识的内存空间标量化，对象化呢？其实是可以的，事实上python就是这么做的。通过采用引用计数的方式来管理这段内存。我们现在要来实现这样
c,c++和python变量讨论
小狼的窝
02-23 1186
<br />c,c++为编译型语言，又称静态语言。变量的类型在编译时就确定了，并且分配了相应的内存空间，一定程度<br /> 上，变量就代表了这块内存空间，就像人名一样。Python为动态类型语言，变量只是一个名称而已，<br /> 不代表某个内存空间。<br /><br /> C语言中，变量就相当于一个盒子，盒子的名字就是变量，无论盒子里的内容怎么变，盒子及其名称一旦<br /> 确定（编译时），就不可再更改。C++亦是如此,但是c++同时也引入了引用的概念，引用不是普通的变量，<br /> 它
c++变量重新赋值_关于Python的变量，我就说一句话
weixin_39771791的博客
11-22 122
在多年开发和教学 Python 的过程中，有一个 bug，出现的频率非常高，经常有人会踩坑：person 你觉得输出结果是什么（单选）：{'name': 'Jack', 'id': 0}{'name': 'Pony', 'id': 1}{'name': 'Crossin', 'id': 2}{'name': 'Pony', 'id': 2}{'name': 'Crossin', 'id': 1}在...
c++中的引用和python中的引用_浅谈python中的引用、拷贝、指针与C++的区别
weixin_32101177的博客
03-03 215
最近在学C++，在刷题的时候遇到了关于引用、指针的问题，重温相关知识后发现C++中的引用于python中引用有很大的区别，我想这就是C++效率远高于python的原因之一。通过两篇文章想梳理下python与C++在引用上的区别以及C++中引用和指针的区别。Python的引用在python中引用就是引用赋值,等同于浅拷贝，可以看一个例子：In [13]: a = 1In [14]: b = aIn ...
python和c语言全局变量,Python如何实现C/C++全局变量？
weixin_42509267的博客
05-22 364
当我在阅读SWIG文档时，我读了以下几行。。在E> C/C++全局变量完全由SWIG支持。但是，由于Python赋值的工作方式，底层机制与您可能预期的有所不同。在Python中键入以下内容时a=3.4“a”成为包含值3.4的对象的名称。如果您稍后键入b=a那么“a”和“b”都是包含值3.4的对象的名称。因此，只有一个对象包含3.4，“a”和“b”都是引用它的名称。这与C语言大不相同，在C语言...
使用C++调用Python代码的方法步骤
08-25
安装Python时，我们需要选择添加Python路径到环境变量中，这样我们才能在C++中正确地调用Python函数。 在VS中，我们需要配置环境和库。右击项目->属性->VC++目录，添加包含目录为Python安装路径/include，库目录为...
python之变量
12-21
1、变量的理解：  我们在中学时代学习方程时，如y = x + 1 里面的x、y都是变量。在我们的计算机编程语言中也...a = ‘yjy’ #表示字符串（注意：在python中，字符串用单引号、双引号表示都可以，但在C，JAVA，C++，字
python调用c++传递数组的实例
09-19
在Python编程中，有时我们需要利用C++库的功能，特别是在处理高性能计算或系统级操作时。在这种情况下，Python可以通过使用C接口来调用C++代码。本文将深入探讨如何在Python中调用C++函数并传递数组作为参数。 首先...
qt creator C++调用python 配置
qq_29800261的博客
03-30 668
一、配置环境 Qt creator 4.14.1 64位 python3.8 64位 pycharm 二、python环境变量配置 此电脑-右键-属性-高级系统设置-环境变量-系统变量-path-新建。 将python安装路径以及Scripts文件路径复制到此处。（我用的pycharm安装的python） 然后一直确定即可。 三、qt配置 1.新建一个项目，比如untitled13; 2.打开untitled13.pro文件，在右边代码区域右键-添加库； 选择外部库-下一步-如图所示设置，只需要选择库文件
QT 编程中保存全局数据的几种方法
petrosofts的博客
02-11 7894
QT 编程中保存全局数据的几种办法 QT做较大项目时总是有一些数据全局都会用到，比如option，setting之类的信息，在软件项目各处都需要随时访问，如何保存这些数据，使程序干净、清爽，又使用方便，是一门学问。 1. 全局变量 global variable 最简单的方法是全局变量，一般有点素养的程序员就不会采用这种办法，更不用说有“面向对象强迫症”的码农了，这种方法只限于很小的项目，不推荐。...
C++与 python 变量生存周期比较
CYummy的博客
04-01 508
1、C++中变量生存周期 参考：https://blog.csdn.net/darkxiaoming/article/details/70232620 在C++中变量有以下两种生存周期： 变量由编译程序在编译时给其分配存储空间（称为静态存储分配），并在程序执行过程中始终存在。这类变量的生存周期与程序的运行周期相同，当程序运行时，该变量的生存周期随即存在，程序运行结...
Qt C++通过cmd命令行调用python脚本（机器学习深度学习算法）文件-----传入脚本文件参数并获取脚本文件的输出结果
最新发布
qq_45573192的博客
07-30 1602
【代码】Qt C++通过cmd命令行调用python脚本（机器学习深度学习算法）文件-----传入脚本文件参数并获取脚本文件的输出结果。
C++和python中的变量定义时的区别
芯碎王子
07-07 768
C++和python中的变量定义时的区别 这张图比较全面的显示了python和C变量定义时的区别： C/C++：变量对应内存中的一块区域，当修改这个值时，直接修改内存区域中的值。 python：变量只是对一块存放指定值的内存区域的引用，赋值时是让该变量引用另一块存放新值的内存区域。因此在赋值时等号左边的变量类似于标签，等号右边的是值对应的地址。 例如下python程序： t = [0] #定义一个只有0值的列表 a = t #将列表赋值给变量a print(id(t)) #id
5分钟掌握 Python 对象的引用
Python中文社区
12-24 1054
1. 引言引用在各种编程语言中都有涉及，如java中值传递和引用传递。python的对象引用也是学习python过程中需要特别关注的一个知识点，特别是对函数参数传递，可能会引起不必要的B...
c++集成Python
mfkjq的专栏
06-20 2179
转自：http://blog.csdn.net/georgedidi/article/details/52277087 参考：http://www.cnblogs.com/bluebbc/p/4291251.html 1.简介 C++ 与 python都是用的比较广泛的语言，各有各的优点；C++性能优异，python简单方便库丰富，如果能够结合两者使用就很好。 py
对比 C++ 和 Python，谈谈指针与引用
Python猫
07-12 413
C++中的变量和python中的变量有区别吗
07-10
是的，C++中的变量和Python中的变量有一些区别。 1. 静态类型 vs 动态类型：C++是一种静态类型语言，变量在声明时需要指定其类型，并且类型在编译时是固定的。而Python是一种动态类型语言，变量的类型是在运行时...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值