python向dll传入结构体，并用tkinter制作界面实现 作业调度算法

最新推荐文章于 2023-03-14 16:08:05 发布
最新推荐文章于 2023-03-14 16:08:05 发布
阅读量615 收藏 3
点赞数 1
分类专栏： python 文章标签： python和c混合编辑 dll 结构体指针 tkinter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38499902/article/details/85411083
版权

本文可以获取信息：

  1. python和c混合编程
  2. python如何向dll中传入结构体数组
  3. 本设计语言采用python3、c，工具采用pycharm、dev c++

最近小狼在研究关于作业调度的一个设计

调度方面，使用c语言肯定是足以实现这个要求的，虽然界面…好吧，那就没有界面。小狼正好了解一丢丢python知识，于是想着能不能python写个界面，然后把数据给c处理呢？索性借此学习一下关于python和c的混合编程。

所以，小狼的思路如下：

  1. 首先使用c语言写出关于设计的计算部分，提供函数计算处理数据
  2. 使用python编写窗口界面，这里需要用到python自带的tkinter库（python还有其他主流的GUI库有WxPython和PyQt库，大家可以自行了解）。
  3. 将python窗口所获取的数据存入定义的数据结构中，然后将数据结构传入dll中，经过处理后再返回给python，然后显示

OK，大概思路就是如此

详细代码：

dll.h

#ifndef _DLL_H_
#define _DLL_H_

#if BUILDING_DLL
# define DLLIMPORT __declspec (dllexport)
#else /* Not BUILDING_DLL */
# define DLLIMPORT __declspec (dllimport)
#endif /* Not BUILDING_DLL */

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct
{
    char task_name[10];//作业名称
    float arrive_time;//到达时间
    float run_time;//要求服务时间
    float startime;//开始时间
    float finitime;//完成时间
    float TAtime,TAWtime;//周转时间，带权周转时间
    float prio;//响应比 
}job_information;

typedef struct
{
	job_information *jcb;
	int len;
	float ave_TAtime; //平均作业周转时间
	float ave_TAWtime; //平均带权作业周转时间
}outStruct;

int __declspec(dllexport) struct_init(outStruct *o);

void __declspec(dllexport) struct_over(outStruct *o); 

void __declspec(dllexport) manage(outStruct *o);

void __declspec(dllexport) FCFS(outStruct *o); 

void __declspec(dllexport) SJF(outStruct *o); 

void __declspec(dllexport) HRRF(outStruct *o); 

#endif /* _DLL_H_ */

dllmain.c

#include "dll.h"

// 初始化，分配初始内存 
int struct_init(outStruct *o)
{
	o->jcb = (job_information *)malloc(sizeof(char)*10*o->len);
	if(o->jcb == NULL) // 判断内存分配是否成功 
	{
		return 1;
	}
	return 0; 
}

// 程序结束，释放内存 
void struct_over(outStruct *o)
{
	free(o->jcb);
	
	o->jcb = NULL; // 释放后的指针置空，防止野指针 
}

// 进行时间上的排序 
void manage(outStruct *o)
{
	int i, j;
	for(j=0;j<o->len;j++)
    {
        for(i=0;i<o->len-j;i++)
        {
            if(o->jcb[i].arrive_time>o->jcb[i+1].arrive_time)
            {
                o->jcb[o->len]=o->jcb[i];
                o->jcb[i]=o->jcb[i+1];
                o->jcb[i+1]=o->jcb[o->len];
            }
        }
    }
}

//先来先服务
void FCFS(outStruct *o)
{
    int i;
    float sum_TAtime=0;//作业总周转时间
    float sum_TAWtime=0;//作业总带权周转时间

    o->jcb[0].finitime = o->jcb[0].arrive_time + o->jcb[0].run_time;
    o->jcb[0].startime = o->jcb[0].arrive_time;
    
    for(i = 1; i < o->len; i++)
    {
        o->jcb[i].startime = o->jcb[i-1].finitime;
        o->jcb[i].finitime = o->jcb[i-1].finitime + o->jcb[i].run_time;
    }
    for(i = 0; i < o->len; i++)
    {
        o->jcb[i].TAtime = o->jcb[i].finitime - o->jcb[i].arrive_time;
        sum_TAtime += o->jcb[i].TAtime;
        o->jcb[i].TAWtime = o->jcb[i].TAtime / o->jcb[i].run_time;
        sum_TAWtime += o->jcb[i].TAWtime;
    }
    o->ave_TAtime = sum_TAtime*1.0/o->len;
    o->ave_TAWtime = sum_TAWtime*1.0/o->len;
}

//最短作业优先
void SJF(outStruct *o)
{
    int i, j;
    float sum_TAtime=0;//作业总周转时间
    float sum_TAWtime=0;//作业总带权周转时间
    
    o->jcb[0].finitime = o->jcb[0].arrive_time + o->jcb[0].run_time;
    o->jcb[0].startime = o->jcb[0].arrive_time;
    
    for(i = 1; i < o->len; i++)
    {
        for(j = 1; j <  o->len-1; j++)
        {
            if(o->jcb[j].run_time > o->jcb[j+1].run_time)
            {
                o->jcb[o->len] = o->jcb[j]; 
                o->jcb[j] = o->jcb[j+1]; 
                o->jcb[j+1] = o->jcb[o->len];
            }
        }
    }
    for(i = 1; i < o->len; i++)
    {
        o->jcb[i].startime = o->jcb[i-1].finitime;
        o->jcb[i].finitime = o->jcb[i-1].finitime + o->jcb[i].run_time;
    }
    for(i = 0; i < o->len; i++)
    {
        o->jcb[i].TAtime = o->jcb[i].finitime - o->jcb[i].arrive_time;
        sum_TAtime += o->jcb[i].TAtime;
        o->jcb[i].TAWtime = o->jcb[i].TAtime / o->jcb[i].run_time;
        sum_TAWtime += o->jcb[i].TAWtime;
    }
    o->ave_TAtime = sum_TAtime*1.0/o->len;
    o->ave_TAWtime = sum_TAWtime*1.0/o->len; 
}

//最高响应比优先
void HRRF(outStruct *o)
{
    int i, j;
    float sum_TAtime=0;//作业总周转时间
    float sum_TAWtime=0;//作业总带权周转时间
     
    o->jcb[0].finitime = o->jcb[0].arrive_time + o->jcb[0].run_time;
    o->jcb[0].startime = o->jcb[0].arrive_time;
   
    for(i = 1; i <o->len; i++)
    {
        for(j = 1; j < o->len-1; j++)
        {
            if(o->jcb[j].prio < o->jcb[j+1].prio)
            {
                if(o->jcb[j].arrive_time == o->jcb[j+1].arrive_time)
                {
                    o->jcb[o->len] = o->jcb[j]; 
                    o->jcb[j] = o->jcb[j+1]; 
                    o->jcb[j+1] = o->jcb[o->len];
                }
            }
        }
    }
    for(i = 1; i <o->len; i++)
    {
        o->jcb[i].prio = 1 + (o->jcb[i-1].finitime - o->jcb[i].arrive_time) / o->jcb[i].run_time;
        o->jcb[i].finitime = o->jcb[i-1].finitime + o->jcb[i].run_time;
    }

    for(i = 0; i <o->len; i++)
    {
        o->jcb[i].TAtime = o->jcb[i].finitime - o->jcb[i].arrive_time;
        sum_TAtime += o->jcb[i].TAtime;
        o->jcb[i].TAWtime = o->jcb[i].TAtime / o->jcb[i].run_time;
        sum_TAWtime += o->jcb[i].TAWtime;
    }
    o->ave_TAtime = sum_TAtime*1.0/o->len;
    o->ave_TAWtime = sum_TAWtime*1.0/o->len;
}

taskSchedule. py

from ctypes import *
from tkinter import *

# 定义关于作业信息的结构体
class job_information(Structure):
    _fields_ = [("name", c_char*10),
                ("arrive_time", c_float),  # 作业到达时间
                ("run_time", c_float),  # 作业所需的运行时间
                ("startime", c_float),  # 开始时间
                ("finitime", c_float),  # 完成时间
                ("TAtime", c_float),  # 周转时间
                ("TAWtime", c_float),  # 带权周转时间
                ("prio", c_float)] # 响应比

class outStruct(Structure):
    _fields_= [('jcb', POINTER(job_information)),
               ('len', c_int), # 作业数量
               ('ave_TAtime', c_float), # 平均作业周转时间
               ('ave_TAWtime', c_float)] # 平均带权作业周转时间

# 对表格中值的读取，保存和打印
def printTable():
    global i

    o.len = o.len + 1

    if i == 5:
        Label(master, text="名称").grid(row=i, column=0)
        Label(master, text="到达时刻").grid(row=i, column=1)
        Label(master, text="运行时间").grid(row=i, column=2)

    i = i + 1
    # 获取表格中值
    o.jcb[o.len-1].name = name_table.get().encode('utf-8')     # encode()将字符串转化为二进制
    o.jcb[o.len-1].arrive_time = float(arrive_time_table.get())
    o.jcb[o.len - 1].run_time = float(run_time_table.get())

    # 打印表格中值
    Label(master, text=o.jcb[o.len-1].name.decode('utf-8')).grid(row=i, column=0)      # decode()将二进制转化为字符串
    Label(master, text=o.jcb[o.len-1].arrive_time).grid(row=i, column=1)
    Label(master, text=o.jcb[o.len-1].run_time).grid(row=i, column=2)

    # 清空表格
    name_table.delete(0,'end')
    arrive_time_table.delete(0,'end')
    run_time_table.delete(0,'end')


# 对保存好的值进行计算和输出
def caculate():
    def FCFS():
        lib.manage(byref(o))
        lib.FCFS(byref(o))

        Label(print_win, text="名称").grid(row=1, column=0)
        Label(print_win, text="到达时刻").grid(row=1, column=1)
        Label(print_win, text="运行时间").grid(row=1, column=2)
        Label(print_win, text="开始时间").grid(row=1, column=3)
        Label(print_win, text="结束时间").grid(row=1, column=4)

        for i in range(o.len):
            # 打印表格中值
            Label(print_win, text=o.jcb[i].name.decode('utf-8')).grid(row=i+2, column=0)  # decode()将二进制转化为字符串
            Label(print_win, text=o.jcb[i].arrive_time).grid(row=i+2, column=1)
            Label(print_win, text=o.jcb[i].run_time).grid(row=i+2, column=2)
            Label(print_win, text=o.jcb[i].startime).grid(row=i+2, column=3)
            Label(print_win, text=o.jcb[i].finitime).grid(row=i+2, column=4)

    def SJF():
        lib.manage(byref(o))
        lib.SJF(byref(o))

        Label(print_win, text="名称").grid(row=1, column=0)
        Label(print_win, text="到达时刻").grid(row=1, column=1)
        Label(print_win, text="运行时间").grid(row=1, column=2)
        Label(print_win, text="开始时间").grid(row=1, column=3)
        Label(print_win, text="结束时间").grid(row=1, column=4)
        Label(print_win, text="周转时间").grid(row=1, column=5)
        Label(print_win, text="带权周转时间").grid(row=1, column=6)

        for i in range(o.len):
            # 打印表格中值
            Label(print_win, text=o.jcb[i].name.decode('utf-8')).grid(row=i+2, column=0)  # decode()将二进制转化为字符串
            Label(print_win, text=o.jcb[i].arrive_time).grid(row=i+2, column=1)
            Label(print_win, text=o.jcb[i].run_time).grid(row=i+2, column=2)
            Label(print_win, text=o.jcb[i].startime).grid(row=i+2, column=3)
            Label(print_win, text=o.jcb[i].finitime).grid(row=i+2, column=4)
            Label(print_win, text=o.jcb[i].finitime).grid(row=i+2, column=5)
            Label(print_win, text=o.jcb[i].finitime).grid(row=i+2, column=6)

    def HRRF():
        lib.manage(byref(o))
        lib.HRRF(byref(o))

        Label(print_win, text="名称").grid(row=1, column=0)
        Label(print_win, text="到达时刻").grid(row=1, column=1)
        Label(print_win, text="运行时间").grid(row=1, column=2)
        Label(print_win, text="开始时间").grid(row=1, column=3)
        Label(print_win, text="结束时间").grid(row=1, column=4)

    def end():
        master.destroy() # 关闭输入值窗口
        print_win.destroy() # 关闭计算窗口
        lib.struct_over(byref(o)) # 释放资源

        for i in range(o.len):
            # 打印表格中值
            Label(print_win, text=o.jcb[i].name.decode('utf-8')).grid(row=i+2, column=0)  # decode()将二进制转化为字符串
            Label(print_win, text=o.jcb[i].arrive_time).grid(row=i+2, column=1)
            Label(print_win, text=o.jcb[i].run_time).grid(row=i+2, column=2)
            Label(print_win, text=o.jcb[i].startime).grid(row=i+2, column=3)
            Label(print_win, text=o.jcb[i].finitime).grid(row=i+2, column=4)

    print_win = Tk()
    print_win.title('作业调度计算')

    Button(print_win, text="先来先服务", command=FCFS).grid(row=0, column=0, sticky=W)

    Button(print_win, text="最短作业优先", command=SJF).grid(row=0, column=1, sticky=E)

    Button(print_win, text="最高响应比优先", command=HRRF).grid(row=0, column=2, sticky=E)

    Button(print_win, text="结束", command=end).grid(row=0, column=3, sticky=E)

    print_win.mainloop()

if __name__ == "__main__":
    lib = cdll.LoadLibrary("./test_dll.dll")
    o = outStruct()

    fill = lib.struct_init(byref(o))

    if fill == 1:
        print("内存分配失败")

    o.len = 0

    master = Tk()
    master.title('单通道作业调度算法')

    global i # 控制界面输出行
    i = 5

    Label(master, text="名称：").grid(row=0)
    name_table = Entry(master)
    name_table.grid(row=0, column=1)

    Label(master, text="作业到达时刻：").grid(row=1)
    arrive_time_table = Entry(master)
    arrive_time_table.grid(row=1, column=1)

    Label(master, text="作业运行时间：").grid(row=2)
    run_time_table = Entry(master)
    run_time_table.grid(row=2, column=1)

    next = Button(master, text="下一个", command=printTable).grid(row=4, column=1, sticky=W)

    submit = Button(master, text="提交", command=caculate).grid(row=4, column=1, sticky=E)

    master.mainloop()
过程中关键部分：
  1. 分别在python文件和c文件中建立对应的结构体
  2. python中实现读取GUI中读取输入框信息，以及在窗口显示信息
  3. c中对于传入的结构体的处理（由于使用了指针，所以传入和传出值的过程就很简单了）
过程中注意问题：

c中malloc()分配内存时，一定要注意进行判断是否申请成功，当函数未能成功分配存储空间（如内存不足）就会返回一个NULL指针，确保非空之后再使用函数。同样，在使用完内存块之后，我们要手动的去释放所申请内存，防止出现内存泄漏等等情况。

// 初始化，分配初始内存 
int struct_init(outStruct *o)
{
	o->jcb = (job_information *)malloc(sizeof(char)*10*o->len); 
	if(o->jcb == NULL) // 判断内存分配是否成功 
	{
		return 1;
	}
	return 0; 
}

// 程序结束，释放内存 
void struct_over(outStruct *o)
{
	free(o->jcb);
	
	o->jcb = NULL; // 释放后的指针置空，防止野指针 
}

python3中，默认编码为utf-8，对于str传给c语言时，需要使用encode()函数转为bytes，同样，c中传给python的bytes需要使用decode()函数转为str

# 获取表格中值
o.jcb[o.len-1].name = name_table.get().encode('utf-8')     # encode()将字符串转化为二进制

# 打印表格中值
Label(master, text=o.jcb[o.len-1].name.decode('utf-8')).grid(row=i, column=0)      # decode()将二进制转化为字符串
有个问题：

在程序中我在c内申请内存代码如下
o->jcb = (job_information *)malloc(sizeof(char)*10 * o->len);
我所申请的空间是依据我首次传入的o->len的大小，而在后面会出现需求内存大于申请内存的情况。这该如何解决？
(当然我直接把o->len改为个具体的实数比如400，1000也能行，但有没有办法在程序运行过程中根据需求，去扩大我的内存量呢?)

有关链接：

在这次设计过程中，小狼也是遇见了很多很多问题，查看了很多资料，部分如下：

  1. Python与C参数交互—结构体指针作为参数.
  2. Python 调用 C 动态链接库，包括结构体参数、回调函数等.
  3. 官方文档对于ctypes的解读.
憨憨至极的胖子
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python dll c 结构体
09-16
加密工具不好写，用到很多结构体，幸好python里面定义了ctypes
Python实现结构体代码实例
09-17
在Python中，我们通常通过定义类（class）来实现类似于结构体的功能。下面将详细介绍如何使用Python实现结构体，并通过具体的代码实例进行讲解。 在Python中，类是一种自定义的数据类型，可以包含数据成员（属性）...
python dll 指针_使用Python Ctypes将struct指针传递给DLL函数
weixin_39603217的博客
12-05 230
我试图使用Python ctypes访问DLL文件中的函数.提供的功能描述如下.Prototype: Picam_ConnectDemoCamera( PicamModel model,const pichar* serial_number,PicamCameraID* id )Description: Virtually connects the software-simulated 'mode...
SDK_03_Python调用C的Dll动态链接库_02_结构体作为参数
weixin_42604772的博客
11-02 227
1. 准备一个dll文件 1.1 自定义dll文件 基于Dev-C++生成dll动态链接库 1.2 使用提供的MyDll.dll 说明: 该dll文件中包含一个printBook方法及一个book结构体,将结构体作为方法参数传入,在方法中打印结构体的属性,并返回指定字符串 结构体定义如下: typedef struct book { char title[50]; char author[50]; char subject[100]; int book_id; } Book
python传递c语言dll数据结构,如何将C结构传递给Python以获取数据？
weixin_42501631的博客
05-19 144
我有Python和C的代码，它们需要通过Popen创建的管道相互通信。我有一个C语言的测试结构，需要传递回Python，但我似乎无法在Python端重建该结构。这是一个复杂得多的项目，但我下面创建的结构只是一个让代码正常工作的示例，我可以在以后尝试找出更高级的东西。我不是C，指针和管道方面的专家，我对它也没有一个清晰的理解。下面的大部分C代码都是我读到的。在Python：testStruct = ...
python 调用dll 动态链接库 结构体参数及回调函数等示例
gmHappy
06-04 5691
结构体示例： 这里是 C 代码的部分，主要是结构体的声明和回调函数定义。 // 新版本定义 typedef enum { DevCard, DevLocator, DevReader } DevType; typedef enum { MsgLocate, // 定位信号 MsgCut, // 剪断信号 MsgHeartB...
C#调用C++DLL传递结构体数组的终极解决方案
08-31
【C#调用C++DLL传递结构体数组的终极解决方案】 在C#和C++混合编程中，常常需要跨语言调用DLL中的函数，而结构体数组是常见的数据传输对象。由于C#和C++对内存管理的方式不同，直接传递结构体数组可能会遇到问题。...
天津理工大学操作系统实验1-处理机调度算法的实现
12-27
本实验主要目的是让学生理解和掌握操作系统中处理机调度的基本原理，特别是涉及进程的概念、状态转换以及调度算法的实现。实验中，学生需要设计并实现一个模拟操作系统处理机调度的程序，采用两种调度算法：最高优先...
C语言实现多级反馈队列调度算法
12-26
通过这个C语言实现，你不仅可以加深对多级反馈队列调度算法的理解，还可以提高编程和系统分析能力。这种调度策略的灵活性使得它能够适应各种不同的工作负载，为现代操作系统提供了高效的任务调度机制。
CPU调度算法的模拟实现课程设计.doc
05-05
本课程设计旨在通过编写程序语言，模拟实现四种 CPU 调度算法：先到先服务算法（FCFS）、非抢占最短作业优先算法（SJF）、可抢占优先权调度算法（PRIOR）和时间片轮转算法（RR）。通过设计和实现这些算法，学生将...
计算机操作系统进程作业调度算法（带实时动态图GUI）
06-10
计算机操作系统进程作业调度算法（带实时动态图GUI），计算机操作系统进程作业调度算法（带实时动态图GUI）。
处理机调度算法的实现GUI界面_JAVA版
07-18
设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。 也就是说能运行的进程数大于处理机个数。为了使系统中的进程能有条不紊地工作，必须 选用某种调度策略，选择一进程占用处理机。要求学生设计一个模拟处理机调度算法，以 巩固和加深对处理机调度概念的认识。 设计要求： 1）先由用户输入进程数量（至少5 个进程），再由系统随机生成一个进程序列（包括到达 时间和服务时间）。 2）然后显示进程调度算法由用户选择，包括：时间片轮转法，短作业优先算法，动态优先级算法。 3）采用GUI界面显示，显示内容包括每个进程的开始时间、完成时间、周转时间以及带权 周转时间，显示界面可参考书本的例子以表格形式但可不要表格线。
python调用dll动态库传入结构体作为参数
youyudexiaowangzi的专栏
12-17 7689
test.h中定义结构体 test.h #include #include #define ARRAY_NUMBER 20 #define STR_LEN 20 typedef struct _tag_Struct { int number; char* pChar; //窄字符字符串 c
ctypes 操作 python 与 c++ dll 互传结构体指针
weixin_30597269的博客
06-25 434
CMakeLists.txt # project(工程名) project(blog-3123958139-1) # add_library(链接库名称 SHARED 链接库代码) add_library(dll_ SHARED dll_.cpp) dll_.cpp #include <iostream> using namespace std; // c+...
【tkinter】Gui界面 tkinter的vb可视化工具，直接生成python代码
热门推荐
捕获完成
02-22 1万+
博客已经搬家到“捕获完成”： https://www.v2python.com 下载地址： http://pan.baidu.com/s/1kVLOrIn#list/path=%2F 依次安装，运行vb控件即可 0.简介 这是一个VB6的ADDIN（外接程序），用于使用VB6开发工具直接拖放控件，直接可视化完成Python的TKint...
Python调用C的Dll的函数（参数为结构体，数组，结构体数组）
more_HH
03-14 1120
对了，我是问的chatGPT，然后自己验证改了一两行而已，nice or 可怕？
Python调用 dll 文件
的专栏
09-10 1万+
Windows 系统 VC 编译器 // func.c #ifdef _MSC_VER #define DLL_EXPORT __declspec( dllexport ) #else #define DLL_EXPORT #endif DLL_EXPORT int add(int a,int b) { return a+b; } 编译：cl /LD func.c...
python 调用dll总结
Christo的博客
11-11 2494
python 调用dll示例
原创二胡音色源文件，可以让热爱电子乐喜欢做MIDI音乐的朋友，做参考音源
最新发布
08-14
原创二胡音色源文件，可以让热爱电子乐喜欢做MIDI音乐的朋友，做参考音源。这里开源给大家，希望能帮助到您
使用c++ 结构体，实现sjf短作业优先调度算法
04-26
好的，让我向您解释一下如何使用C结构体来实现SJF短作业优先调度算法。 首先，我们需要定义一个结构体来表示每个作业的信息，包括作业的名称、到达时间、服务时间和等待时间。结构体可以定义如下： ```c struct ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值