C++实现Python变量

最新推荐文章于 2023-02-08 11:07:03 发布
最新推荐文章于 2023-02-08 11:07:03 发布
阅读量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变量传递
liualiang的博客
03-31 1157
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字符串转矩阵_python将字符串转为矩阵
weixin_39949584的博客
12-03 3627
将字符串转换为矩阵，分为四步：１.将字符串切分为一个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....
听说Python成为世界性语言了？ Python是怎么构建世界？基础在哪里？(一)
abc19991119的博客
02-08 234
从0开始，循序渐进,变量、数据类型、控制语句、容器、函数和面向对象等
使用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...
C++调用Python，Python访问C++中的数据
puretech_的专栏
10-02 3333
今天遇到的麻烦是前两天设计考虑不周详导致的。 在传统的设计思路中，留给后期运行时可以扩展的部分通常交给数据库的存储过程实现。 例如：保存某数据时，对数据的检查。获得某数据时，对数据的格式化等等。 我一开始设计时也是如此考虑的，在设计数据保存表时，考虑了保存、检查、获取记录时可以选择的额外处理： CREATE TABLE IF NOT EXISTS TCI_TYPE ( FCITYPE
C++ 调用Python
Kite_crazy的专栏
08-24 642
C++ 调用Python前提 已经配好Python环境。在c++项目中引入 包含目录：C:\Python27\include 库目录： C:\Python27\libs 在源代码加入头文件 : #include 通用撸码步骤 第一步：初始化Python 第二步：引入Python模块 第三步：调用模块里的函数 第四步：调用函数并获取返回值 第五步：关闭python 解析复
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（混合编程）函数整理总结
jindayue的博客
12-05 1万+
python是一种非常强大的胶水语言，可以灵活的嵌入到c++和java等主流语言中。python提供了一套C的API库，是的开发者能够很方便的从C、C++的程序中调用python中的各个功能模块。c++ 调用 python ，本质上是在 c++ 中启动了一个 python 解释器，由解释器对 python 相关的代码进行执行，执行完毕后释放资源，达到调用目的。从操作步骤上看，C++调用Python低层接口可以分为几个阶段：和环境相关的接口如下： 2.调用python脚本的两种方式 第一种方法示例： 第一种
Python 与 C/C++ 交互的几种方式
weixin_34177064的博客
05-08 452
　　python作为一门脚本语言，其好处是语法简单，很多东西都已经封装好了，直接拿过来用就行，所以实现同样一个功能，用Python写要比用C/C++代码量会少得多。但是优点也必然也伴随着缺点（这是肯定的，不然还要其他语言干嘛），python最被人诟病的一个地方可能就是其运行速度了。这这是大部分脚本语言共同面对的问题，因为没有编译过程，直接逐行执行，所以要...
C++/Python：保存C++中的变量用python画图
己亥谷雨
06-14 402
使用python对C++中的变量画图
Python整型：布尔型、标准整型、长整型操作实例
WEL测试
02-21 1万+
#coding=utf8 def integerType(): ''' 布尔型： 该值的取值范围只有两个值：True(1)、False(0) ''' Tbool=True Fbool=False print "The True is stand for %d" %(Tbool) print "The False is stand f
EINT、DINT、ERTM、DRTM和INTM、DBGM解析
吴建梅的专栏
05-07 8096
一、参考DSP281x_Device.h #define  EINT   asm(" clrc INTM")  //INTM置0，开中断 #define  DINT   asm(" setc INTM")  //INTM置1，关中断 #define  ERTM   asm(" clrc DBGM")  //使能调试事件 #define  DRTM   asm(" setc
Python&C++相互混合调用编程全面实战-15C++读取python脚本中的dictionary字典变量以及它的键值对
编辑编辑器
06-18 1772
作者：虚坏叔叔 博客：https://xuhss.com在中定义一个字典，用于C++的读取 二、C++获取python主模块 在C++中，可以根据名称获取字典，在获取名称之前，首先需要获取主模块。主模块可以通过获取。下面代码中的就是获取到的主模块。这里返回的指针都是需要开发者手动清理的。关键代码如下： 三、获取字典对象以及它的键值对 获取到模块之后 根据模块和变量名称来获取对象。获取到字典变量对象conf后，就可以操作conf获取到它的键值对。关键代码如下 完整代码如下： F5运行可以看到成功获取了：关注下
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、付费专栏及课程。

余额充值