C++ has a far richer set of builtin types than Python.
Most Python code can remain relatively agnostic to that, and
provides automatic conversions as appropriate.
On the other hand, Python builtin types such as lists and maps are far
richer than any builtin types in C++.
These are mapped to their Standard Template Library equivalents instead.
The C++ code used for the examples below can be found
here, and it is assumed that that code is
loaded at the start of any session.
Download it, save it under the name
features.h, and load it:
>>> import cppyy >>> cppyy.include('features.h') >>>
Most builtin data types map onto the expected equivalent Python types, with
the caveats that there may be size differences, different precision or
For example, a C++
float is returned as a Python
float, which is in
fact a C++
If sizes allow, conversions are automatic.
For example, a C++
unsigned int becomes a Python
unsigned-ness is still honored:
>>> type(cppyy.gbl.gUint) <type 'long'> >>> cppyy.gbl.gUint = -1 Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: cannot convert negative integer to unsigned >>>
Builtin arrays are supported through arrays from module
array (or any
other builtin-type array that implements the Python buffer interface, such
as numpy arrays) and a low-level view type from
cppyy for returns and
variable access (that implements the buffer interface as well).
Out-of-bounds checking is limited to those cases where the size is known at
>>> from cppyy.gbl import Concrete >>> from array import array >>> c = Concrete() >>> c.array_method(array('d', [1., 2., 3., 4.]), 4) 1 2 3 4 >>> c.m_data # static size is 4, so out of bounds Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: buffer index out of range >>>
When the C++ code takes a pointer or reference type to a specific builtin
type (such as an
unsigned int for example), then types need to match
cppyy supports the types provided by the standard modules
array for those cases.
Example of using a reference to builtin:
>>> from ctypes import c_uint >>> u = c_uint(0) >>> c.uint_ref_assign(u, 42) >>> u.value 42 >>>
For objects, a pointer to an object and an object are represented the same way, with the necessary (de)referencing applied automatically. Pointer variables are also bound by reference, so that updates on either the C++ or Python side are reflected on the other side as well.
Both named and anonymous enums are supported.
The type of an enum is implementation dependent and may even be different for
different enums on the same compiler.
Typically, however, the types are
unsigned int, which
translates to Python’s
long on Python2 or class
>>> from cppyy.gbl import kApple, kBanana, kCitrus >>> cppyy.gbl.kApple 78 >>>