解决Qt信号槽传递Python大整数的32位截断问题

问题现象 #

我在不同线程中运行的QObject通过Qt信号槽通信，用的是PyQt5（基于qtpy），但问题不局限于这个API或版本。

要传递的整数量级约为2^40，因为C++的int是32位，导致数值被静默截断。我尝试把信号槽类型换成'long'，但只在部分机器上有效（见测试结果），最后只能把数值包装在单元素元组里——因为Qt会原封不动传递Python对象。

测试用例 #

from qtpy import QtCore
                                                                                                                      
class Sender(QtCore.QObject):                                                                                         
    intsig = QtCore.Signal(int)                                                                                       
    longsig = QtCore.Signal('long')
    tuplesig = QtCore.Signal(tuple)                                                                                   
    done = QtCore.Signal()                                                                                            
        
    def __init__(self, thread):
        super().__init__()                                                                                            
        self.moveToThread(thread)                                                                                     
        thread.started.connect(self.start)                                                                            
        self.done.connect(thread.quit)                                                                                
        
    def start(self):
        QtCore.QTimer.singleShot(1000, self.send)                                                                      
        
    def send(self, value=123456789012345):                                                                            
        self.intsig.emit(value)                                                                                      
        self.tuplesig.emit((value,))                                                                                       
        self.longsig.emit(value)                                                                                  
        self.done.emit()                                                                                              
        
class Receiver(QtCore.QObject):                                                                                         
        
    def __init__(self, thread):
        super().__init__()                                                                                            
        self.moveToThread(thread)                                                                                     
        
    @QtCore.Slot(int)
    def intslot(self, val):                                                                                           
        print(f"intslot: {val}")                                                                                      
                                                                                                                      
    @QtCore.Slot('long') 
    def longslot(self, val):                                                                                          
        print(f"longslot: {val}")
                
    @QtCore.Slot(tuple)                                                                                               
    def tupleslot(self, val):
        print(f"tupleslot: {val[0]}")                                                                                  
    
if __name__ == "__main__":                                                                                            
    qa = QtCore.QCoreApplication(['foo'])                                                                             
    sthread = QtCore.QThread()                                                                                        
    rthread = QtCore.QThread()
    sender = Sender(sthread)
    receiver = Receiver(rthread)
    sender.intsig.connect(receiver.intslot)                                                                            
    sender.longsig.connect(receiver.longslot)                                                                          
    sender.tuplesig.connect(receiver.tupleslot)                                                                       
    sthread.finished.connect(rthread.quit)                                                                            
    rthread.finished.connect(qa.quit)                                                                                 

    rthread.start()                                                                                                   
    sthread.start() 
    qa.exec()
    sthread.wait()
    rthread.wait()

测试结果 #

开发机器（Gentoo Linux 2023年3月更新，amd64架构） #

$ python3.8 --version && python3.8 -m test
Python 3.8.16
intslot: -2045911175
tupleslot: 123456789012345
longslot: 123456789012345
$ python3.9 --version && python3.9 -m test
Python 3.9.16
intslot: -2045911175
tupleslot: 123456789012345
longslot: 123456789012345
$ python3.10 --version && python3.10 -m test
Python 3.10.10
intslot: -2045911175
tupleslot: 123456789012345
longslot: 123456789012345

目标机器（基于Debian 11.6的Raspberry Pi OS，RPi 4 Model B Rev 1.4，armv7l架构） #

$ python --version && python -m test
Python 3.9.2
intslot: -2045911175
tupleslot: 123456789012345
Traceback (most recent call last):
  File "/tmp/test.py", line 21, in send
    self.longsig.emit(value)
TypeError: Sender.longsig[long].emit(): argument 1 has unexpected type 'int'
Aborted

问题问询 #

在Python原生类型转正确C类型的过程中，我是不是漏了什么？类型映射是不是和架构、机器或版本有微妙的依赖关系？把无法适配基础C类型的数据包装成Python对象，是不是处理这类问题的最佳方式？

解决方案与分析 #

1. 类型映射的架构依赖问题 #

你遇到的核心问题是C++基础类型的宽度在不同架构下不一致：

• amd64架构中，long是64位，能容纳你传递的大整数，Python的int可以隐式转换为C++的long；
• armv7l架构中，long是32位，你的大整数超出了它的范围，PyQt无法完成隐式转换，因此抛出类型错误。

这是C++标准的特性：long的宽度由实现定义，并非固定64位。

2. 正确的跨架构类型选择 #

要传递大整数，应该使用固定宽度的C++整数类型，而非依赖平台相关的long。PyQt支持直接指定这些类型：

• 用'qint64'对应C++的int64_t（有符号64位整数，能容纳到9e18，完全覆盖你的2^40需求）；
• 用'quint64'对应无符号64位整数。

修改信号槽的类型定义：

# Sender类中
longsig = QtCore.Signal('qint64')

# Receiver类中
@QtCore.Slot('qint64') 
def longslot(self, val):                                                                                          
    print(f"longslot: {val}")

这样无论在amd64还是armv7l架构下，都能正确传递大整数，不会出现截断或类型错误。

3. 包装Python对象的适用性 #

将数值包装成元组（或其他Python对象）确实是一种通用方案，因为Qt会直接传递Python对象，绕过C++类型转换的限制。但这种方式有两个缺点：

• 信号槽的类型语义不清晰，其他开发者无法直观知道传递的是整数；
• 相比直接使用适配的C++类型，会有轻微的性能开销（虽然大多数场景下可以忽略）。

因此，优先选择固定宽度的C++整数类型是更规范、高效的解决方案，只有在传递非数值类型或极端大的数值（超出64位范围）时，才考虑包装Python对象。

4. 额外注意事项 #

• 如果你使用的是PyQt6，类型映射规则基本一致，但要注意Qt6中部分API的变化；
• 测试跨架构代码时，务必在目标架构上验证类型转换逻辑，避免依赖开发环境的特性。

内容的提问来源于stack exchange，提问作者AI0867