C++实现Python变量

最新推荐文章于 2022-06-14 14:18:53 发布
最新推荐文章于 2022-06-14 14:18:53 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： C/C++ 文章标签： C++智能指针值语义 C++内存管理 C++实现python变量 不再内存泄露 C++自动内存管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liaoyoujinb/article/details/16330219
版权

C++ 变量也能像python变量一样使用---再也不用担心内存泄露---让malloc/free,new/delete见鬼去吧


        仔细想想，其实所有分配在栈和静态存储区的存储空间都是由一个变量来标识，这是由系统自己管理的内存空间，而堆上分配的空间在每次运行期都是不一样的，也就是不是编译期决定的，所以只能用指针来标识。那么我们是否可以将这种指针标识的内存空间标量化，对象化呢？其实是可以的，事实上python就是这么做的。通过采用引用计数的方式来管理这段内存。我们现在要来实现这样的功能。事先声明，我们实现的都是非线程安全的，需要线程安全可以使用互斥锁。


一、dint的实现


 1.设计

        dint是int的封装，它是这样一种数据类型：
              1.本质上是int类型，所以我们希望其可以当成int无差别使用，由于int是内置类型，可以隐式转换，所以借助operator()可实现。
              2.只有构造函数会真正产生新的资源消耗，其他操作只是将dint邦定到已有的内存空间。
              3.dint邦定的内存空间是一段结构体空间，其含有int count(引用计数)，int data(数据)。
              4.形如a = b;这样的操作发生了如图所示的事件。

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){}
};

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;
	}
	operator int&()
	{
		return p->data;
	}
	operator int&() const//convert the const dint
	{
		return p->data;
	}
	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.
};

void test(const dint& i)//covert
{
	cout<<i<<endl;
}

void test2(int &h)
{
	h = 10000;
}

int main()
{
	dint a(10);
	dint b(a);
	dint c = 100;
	c = a;
	cout<<a<<endl;
	if(a < c)cout<<"Success!"<<endl;
	test(90);
	int i = 80;
	test(i);
	
	test2(a);
	cout<<a<<endl;
	
}

        一个解决方案是重载“*“和“->“操作符，那么我们就无法实现python那种调用效果了。但是仍然能够很好的实现内存管理。另一个解决方案是制造一个调用句柄如self()函数。个人比较喜欢self函数。一个解决方案是重载“*“和“->“操作符，那么我们就无法实现python那种调用效果了。但是仍然能够很好的实现内存管理。另一个解决方案是制造一个调用句柄如self()函数。个人比较喜欢self函数。一个解决方案是重载“*“和“->“操作符，那么我们就无法实现python那种调用效果了。但是仍然能够很好的实现内存管理。另一个解决方案是制造一个调用句柄如self()函数。个人比较喜欢self函数。


3.总结 

        这套方案的好处在于，通过将引用计数与结构体内存邦定，而省去了分配表和分配器的开销。不过同样面临一个问题，那就是线程不安全。如果想要安全，那么必须每一个内存块（被分配的）邦定一个互斥锁。还有些问题：

      １． 普通的int(静态＋栈)：无法真正实现将引用传递给dint类型。

      ２． dint类型的可以实现传递给int的引用。

      ３． 也即dint可以完全当作int使用，反之则不行。

      ４． int ,dint间赋值只是简单的值传递。



二、dstring实现


 1.设计 

         dstring是string的封装，它的描述和dint可以类推：有些不同点在于string的operator()不能发生隐式转换，那么将dstring当作string使用必须显示转换，非常麻烦。

        一个解决方案是重载“*“和“->“操作符，那么我们就无法实现python那种调用效果了。但是仍然能够很好的实现内存管理。另一个解决方案是制造一个调用句柄如self()函数。个人比较喜欢self函数。


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){}
};

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

void test(const dstring& i)//covert
{
	cout<<*i<<endl;
	cout<<i.self()<<endl;
}

void test2(string &h)
{
	h = "10000";
}

int main()
{
	dstring a("10");
	dstring b(a);
	//dstring c = "100";
	//c = a;
	string str = "abc";
	str = a;
	cout<<*a<<endl;
	
	test(string("90"));
	string i = "80";
	test(i);
	cout<<(*a).size()<<endl;
	test2(*a);
	cout<<*a<<endl;
	cout<<a.self()<<endl;
	
}
        dstring& operator=(dstring& d)之所以不用常量引用，是为了禁止将常量指针复制给非常量指针，这完全符合C++的 要求，也是出于安全的考虑。

三、通用版dT实现


1.设计      

         对于内置类型，可以通过operator()实现封装类型直接当成基础类型来使用，而类类型的话，我们需要通过重载"*"/"->",或者实现"self()"来达到目的。由于我们此处的设计是值语义的使用封装类型，如果使用"*","->"就会是指针语义，那么这样就更接近于智能指针。我个人倾向于使用self()函数，当然a.self().Fuc()这样的调用也过于冗长，我们需要一个使用起来更简洁的方式，函数U：

template<class T>
typenameT::value_type& U(T& t)
{
     return t.self();
}

template <class T>
const typename T::value_type& U(const T& t)
{
    return t.self();
}
        那么我们就可以这样使用a了： U(a).Fuc()     (Fuc()泛指函数)

        还有一个需要注意的地方，由于const类型对象只能调用const版本的函数，那么operator(),"*","->","self()"

2.实现

        代码：

#include<iostream>
#include<string>
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  Obj_ptr{
public:
typedef T value_type;
public:
   Obj_ptr()
    {
        p = new dtype<T>();
    }
    Obj_ptr(const T& i)
    {
        p = new dtype<T>(i);
    }
    Obj_ptr(const Obj_ptr& d)
    {    
        p = d.p;
        p->count++;
    }
    ~Obj_ptr()
    {
        p->count--;
        if(0 == p->count)
        {
            destory();
        }
    }
    Obj_ptr& operator=(Obj_ptr& d)
    {
        if(this != &d)
        {
            int i = --p->count;
            if(0 == i)destory();
            p = d.p;
            p->count++;
        }
        return *this;
    }
    T& operator*()
    {
        return p->data;
    }
    const T& operator*() const
    {
        return p->data;
    }
    T& self()
    {
        return p->data;
    }
    const T& self() const
    {
        return p->data;
    }
    operator T&()
    {
        return p->data;
    }
    operator T&() const//convert the const Obj_ptr
    {
        return p->data;
    }
    void destory()
    {
        cout<<"really delete the p."<<endl;
        delete p;
    }
private:
    dtype<T>* p; //p is nerver be NULL,it is allways bind to a T.
};

void test(const Obj_ptr<string>& i)//covert
{
    //cout<<i<<endl;
}

void test2(string &h)
{
    h = "Hello Test.";
}
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();
}

int main()
{
    Obj_ptr<string> a(string("Hello Bosch."));
    Obj_ptr<string> b(a);
    Obj_ptr<string> c = string("Hello youjin.");
    c = a;
    cout<<a.self()<<endl;
    test(string("Hello China."));
    test2(a);
    //cout<<a<<endl;
    cout<<a.self()<<endl;
    cout<<U(a)<<endl;
    const Obj_ptr<string> ca(string("Hello Bosch."));
    cout<<ca.self()<<endl;
    cout<<U(ca)<<endl;
}

        该方法的一个特点就是除了构造函数会生成真正意义上的新变量之外，其他操作都只是指针复制等操作。只会改变也有内存的引用计数。

        根据C++11的特性我们还能简化创建变量的代码，设置一个创建函数Ｃ：

template<class T>
Obj_ptr<T>& C()
{
   return  Obj_ptr<T>();
}

template<class T>
Obj_ptr<T>& C(const T&t)
{
   return  Obj_ptr<T>(t);
}

template<class T>
Obj_ptr<T>& C(const Obj_ptr<T> &t)
{
   return  Obj_ptr<T>(t);
}

调用方式：

1.   auto a = C<string>();

2.   auto b = C(string(＂Hello Bosch.＂));

3.   auto c = C(b);

四、总结

      对C++11还不是很了解，但是据说非常强大也许等我看完就可以改进该方案了。该方案的思想是把变量视为两类，一类静态+栈空间，一类堆空间。我们要做的是将对空间的内存分配和销毁对用户透明，不鼓励程序员直接参与malloc/free,new/delete的调用。程序员不需要了解内存的分配情况。
     进一步探讨祥见：C++ 实现Python变量续
东大学子
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从C++到Python（一）I/O与变量
weixin_38889708的博客
02-01 398
从C++到Python  （一）I/O与变量 首篇博客。 前几日看到舍友转载的文章的观点：“一名合格的计算机专业的大学毕业生，要写至少300篇博客”。虽然不敢苟同，但让我重新思考博客的作用，便决定仿效一下，加上最近也在学习python，于是就有了这个系列。 博主曾经学过C++与数据结构，有编程基础，对于新的语言python了解也不多，只知道网络爬虫、机器学习这些都有关系。参考了众多网
python绑定c++程序
12-14 69
python绑定c++程序 python绑定c++程序 - xiaotie - 博客园python绑定c++程序很多时候需要给c++程序提供一种使用上的灵活性，脚本语言在这里就变得很重要了。采用Boost.Python为c++程序加一层shell，比较简单、简洁，...
Python 与 C/C++ 交互的几种方式
weixin_34177064的博客
05-08 450
　　python作为一门脚本语言，其好处是语法简单，很多东西都已经封装好了，直接拿过来用就行，所以实现同样一个功能，用Python写要比用C/C++代码量会少得多。但是优点也必然也伴随着缺点（这是肯定的，不然还要其他语言干嘛），python最被人诟病的一个地方可能就是其运行速度了。这这是大部分脚本语言共同面对的问题，因为没有编译过程，直接逐行执行，所以要...
C++实现Python变量续
liaoyoujinb的专栏
11-15 1302
C++实现Python变量续         想问题总是不够全面，一觉醒来突然发现昨天的实现语义不明朗，有点小问题，本来是想实现值语义的，就像a=100,b = a,b = 101.那么b是不会影响a的值得，如果影响了，那就是指针语义了。昨天的设计就是指针语义。         在C/C++中我们一个变量一般会跟固定的内存邦定，在运行期是不会改变的，只有指针会改变。那么我们会认为指针指向的是不
python类变量与 C++的静态变量并不等效
dengji8846的博客
09-04 102
我们在给python的类定义变量时，有时会定义带self的变量（这种变量是实例成员变量，为每一个实例成员所有，即可以用实例来调用，也可以用类来调用），还有一种变量是类的（在类的内部定义的，不带self属性，有点类似于c++的静态变量，c++为所有实例共享，但c++中的类量变不能通过实例对像来直接修改和调用，而需要通过类来修改和调用， 一旦被修改了，所有的实例看到的该类变...
python实现类的静态变量用法实例
09-22
在Python中，没有像Java或C++那样的`static`关键字来声明静态变量。但是，我们可以通过以下两种方式实现类似的功能： 1. 使用类属性（Class Attributes）：直接在类定义内部设置变量，无需通过任何方法。例如： ``...
使用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++，字
使用C++调用Python代码的方法详解
08-25
在使用C++调用Python代码之前，需要首先安装Python环境，并将Python添加到环境变量中。在VS中，需要配置项目属性，包括包含目录和库目录。包含目录为Python安装路径下的include文件夹，而库目录为Python安装路径下的...
swig 打包C++ python应用
09-26
swig 打包C/C++程序；供python调用。 本软件操作平台windows 10 Vs2017;python3.8; 主要讲述swig vs配置，测试用例。 主要包含常量，变量，指针，结构体定义及运用。
C++ 可变模版的高级使用，模仿python plot输入参数写法
github_39582118的博客
06-05 174
C++ 可变模版非常方便，可以实现任意数量的参数输入，下面用C++可变模版模仿python matplotlib.pyplot.plot 函数，实现任意数量参数输入，并且识别输入变量的类型 类型定义 用宏定义定义一些结构体，实现marker、linewidth等标记类型和变量 #define MO_KEYWORD_INPUT(name, type)
C++/Python：保存C++中的变量用python画图
己亥谷雨
06-14 401
使用python对C++中的变量画图
C++调用Python，Python访问C++中的数据
puretech_的专栏
10-02 3333
今天遇到的麻烦是前两天设计考虑不周详导致的。 在传统的设计思路中，留给后期运行时可以扩展的部分通常交给数据库的存储过程实现。 例如：保存某数据时，对数据的检查。获得某数据时，对数据的格式化等等。 我一开始设计时也是如此考虑的，在设计数据保存表时，考虑了保存、检查、获取记录时可以选择的额外处理： CREATE TABLE IF NOT EXISTS TCI_TYPE ( FCITYPE
C++调用Python变量传递
liualiang的博客
03-31 1156
Python ：(hello.py) def TestList(nlist): print(nlist) return 一般参数都是已元组形式传入的 Py_Initialize(); PyRun_SimpleString("import sys"); PyRun_SimpleString("sys.path.append('./')"); PyObject* pModule =NULL; PyObject
使用Python Snap7读取西门子触摸板 Dint LReal(int double)数据
04-19 1562
因自建公司Mes系统 需要读取s7-1200 HMI 数据 找到python-Snap7模块可以连接s7-1200读取数据 使用过程中发现Snap7.util不支持读取Dint Lreal ,但是struct支持读取int double 修改*\Python37\Lib\site-packages\snap7 下 util.py def get_dint(bytearr...
python字符串转矩阵_python将字符串转为矩阵
weixin_39949584的博客
12-03 3626
将字符串转换为矩阵，分为四步：１.将字符串切分为一个listd = "2 3 4 5 6 8 1 2 "dlist = d.strip(' ').split(' ')２.将list中的ｓｔｒ转换为ｉｎｔdint = map(int, dlist)３.将list转换为arraydarr = np.array(dint)４.将array数组转换为矩阵，这里转为一个三维矩阵daresh = darr....
EINT、DINT、ERTM、DRTM和EALLOW、EDIS、ESTOP0解析
尘埃世界的博客
07-10 7648
#define  EINT   asm(" clrc INTM")  //INTM置0，开中断 #define  DINT   asm(" setc INTM")  //INTM置1，关中断 #define  ERTM   asm(" clrc DBGM")  //使能调试事件 #define  DRTM   asm(" setc DBGM")  //禁止调试事件TI的DSP为了提高安全性能，将很...
C++ 随机函数
热门推荐
ChanJose的博客
12-28 3万+
1.产生随机数： rand()：内部实现是用线性同余法做的，它不是真的随机数，因其周期特别长，故在一定的范围里可看成是随机的。 rand()返回一随机数值的范围在0至RAND_MAX 间。RAND_MAX的范围最少是在32767之间(int)。 所在的头文件：#include &lt;cstdlib&gt; // 标准...
C++中的变量和python中的变量有区别吗
最新发布
07-10
是的，C++中的变量和Python中的变量有一些区别。 1. 静态类型 vs 动态类型：C++是一种静态类型语言，变量在声明时需要指定其类型，并且类型在编译时是固定的。而Python是一种动态类型语言，变量的类型是在运行时确定的，可以根据赋值来自动推断。 2. 变量声明和初始化：在C++中，变量需要显式声明和初始化，否则会引发编译错误。而在Python中，变量可以直接进行赋值，无需事先声明或初始化。 3. 内存管理：C++中的变量存储在栈上或堆上，需要手动进行内存管理。而Python使用垃圾回收机制自动管理内存，无需手动释放内存。 4. 变量作用域：C++中变量的作用域由其在代码中的位置决定，可以在特定的作用域中访问。而Python中变量的作用域由其在代码中的位置以及命名空间决定，可以在更广泛的范围内访问。 5. 引用 vs 引用传递：C++中可以使用指针引用变量，也可以进行引用传递。而Python中没有指针的概念，变量通过引用来访问。 需要注意的是，尽管有这些区别，C++和Python都是强大且广泛使用的编程语言，可以根据具体的需求选择适合的语言。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值