mirror of
https://github.com/RYDE-WORK/pybind11.git
synced 2026-01-19 21:23:26 +08:00
ec62d977c4
This commit adds support for forcing alias type initialization by defining constructors with `py::init_alias<arg1, arg2>()` instead of `py::init<arg1, arg2>()`. Currently py::init<> only results in Alias initialization if the type is extended in python, or the given arguments can't be used to construct the base type, but can be used to construct the alias. py::init_alias<>, in contrast, always invokes the constructor of the alias type. It looks like this was already the intention of `py::detail::init_alias`, which was forward-declared in 86d825f3302701d81414ddd3d38bcd09433076bc, but was apparently never finished: despite the existance of a .def method accepting it, the `detail::init_alias` class isn't actually defined anywhere. This commit completes the feature (or possibly repurposes it), allowing declaration of classes that will always initialize the trampoline which is (as I argued in #397) sometimes useful.
81 lines
1.9 KiB
Python
81 lines
1.9 KiB
Python
import pytest
|
|
import gc
|
|
|
|
def test_alias_delay_initialization(capture, msg):
|
|
|
|
# A only initializes its trampoline class when we inherit from it; if we
|
|
# just create and use an A instance directly, the trampoline initialization
|
|
# is bypassed and we only initialize an A() instead (for performance
|
|
# reasons)
|
|
from pybind11_tests import A, call_f
|
|
|
|
class B(A):
|
|
def __init__(self):
|
|
super(B, self).__init__()
|
|
|
|
def f(self):
|
|
print("In python f()")
|
|
|
|
# C++ version
|
|
with capture:
|
|
a = A()
|
|
call_f(a)
|
|
del a
|
|
gc.collect()
|
|
assert capture == "A.f()"
|
|
|
|
# Python version
|
|
with capture:
|
|
b = B()
|
|
call_f(b)
|
|
del b
|
|
gc.collect()
|
|
assert capture == """
|
|
PyA.PyA()
|
|
PyA.f()
|
|
In python f()
|
|
PyA.~PyA()
|
|
"""
|
|
|
|
def test_alias_delay_initialization(capture, msg):
|
|
from pybind11_tests import A2, call_f
|
|
|
|
# A2, unlike the above, is configured to always initialize the alias; while
|
|
# the extra initialization and extra class layer has small virtual dispatch
|
|
# performance penalty, it also allows us to do more things with the
|
|
# trampoline class such as defining local variables and performing
|
|
# construction/destruction.
|
|
|
|
class B2(A2):
|
|
def __init__(self):
|
|
super(B2, self).__init__()
|
|
|
|
def f(self):
|
|
print("In python B2.f()")
|
|
|
|
# No python subclass version
|
|
with capture:
|
|
a2 = A2()
|
|
call_f(a2)
|
|
del a2
|
|
gc.collect()
|
|
assert capture == """
|
|
PyA2.PyA2()
|
|
PyA2.f()
|
|
A2.f()
|
|
PyA2.~PyA2()
|
|
"""
|
|
|
|
# Python subclass version
|
|
with capture:
|
|
b2 = B2()
|
|
call_f(b2)
|
|
del b2
|
|
gc.collect()
|
|
assert capture == """
|
|
PyA2.PyA2()
|
|
PyA2.f()
|
|
In python B2.f()
|
|
PyA2.~PyA2()
|
|
"""
|