无法从pybind11中的静态函数返回shared_ptr
在pybind11中，无法直接从静态函数返回shared_ptr。这是因为pybind11不支持直接将C++的shared_ptr类型转换为Python对象。
然而，我们可以通过以下方法来解决这个问题：
- 使用std::make_shared创建shared_ptr对象，并将其传递给Python函数。在Python函数中，我们可以使用py::capsule将shared_ptr对象封装为Python对象。这样，我们可以在Python中使用这个对象，并确保其生命周期与C++中的shared_ptr对象一致。
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <memory>
namespace py = pybind11;
std::shared_ptr<int> create_shared_ptr() {
return std::make_shared<int>(42);
}
PYBIND11_MODULE(example, m) {
m.def("create_shared_ptr", []() {
std::shared_ptr<int> ptr = create_shared_ptr();
return py::capsule(ptr.get(), [](void* ptr) {
// 释放资源
std::shared_ptr<int>* shared_ptr = static_cast<std::shared_ptr<int>*>(ptr);
delete shared_ptr;
});
});
}在Python中使用这个函数：
import example
ptr = example.create_shared_ptr()
print(ptr) # <capsule object "int" at 0x7f8b0e2c0b70>
print(ptr.value) # 42- 另一种方法是使用py::cpp_function来包装返回shared_ptr的静态函数。这样，我们可以在Python中直接调用这个函数，并将返回的shared_ptr对象转换为Python对象。
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <memory>
namespace py = pybind11;
std::shared_ptr<int> create_shared_ptr() {
return std::make_shared<int>(42);
}
PYBIND11_MODULE(example, m) {
m.def("create_shared_ptr", py::cpp_function(&create_shared_ptr));
}在Python中使用这个函数：
import example
ptr = example.create_shared_ptr()
print(ptr) # <capsule object "std::shared_ptr<int>" at 0x7f8b0e2c0b70>
print(ptr.value) # 42这些方法可以帮助我们在pybind11中处理无法直接从静态函数返回shared_ptr的情况。通过使用py::capsule或py::cpp_function，我们可以将shared_ptr对象传递给Python，并在Python中使用它。
相关·内容
我正在尝试编译为OpenVSLAM/Stella_vslam的开源项目制作的。
根据存储库指令，我执行以下命令：
/usr/bin/g++ -O3 -Wall -shared -std=c++11 -fPIC $(python3 -m pybind11 --includes) -I/usr/local/include/openvslam/3rd/json/include -DUSE_DBOW2 /home/user/OpenVSLAM-Python-bindings/openvslam_bindings.cpp -o openvslam$(python3-config --extension-
浏览 6提问于2022-05-11得票数 1
回答已采纳
我有两个c++库，它们公开python，但使用两个不同的框架(pybind11和cython)。我需要使用python胶囊在它们之间(两种方式)之间传输一个对象。由于cython和pybind11使用python胶囊的方式不同，甚至可以让它工作吗？
我有一个库A，它定义了一个类Foo，并将它与pybind11公开给python。库B使用cython公开其API。LibB拥有一个shared_ptr<Foo>，它是LibB的一个类的成员，比如说- Bar。
Bar将shared_ptr<Foo>成员作为PyCapsule返回，我在Foo类的pybind11中捕获了该成员。
浏览 0提问于2019-07-19得票数 3
回答已采纳
我有一个虚拟对象，我使用pybind11在Python子类化和实现，然后在C++代码中使用该对象，但是当python脚本结束时，python对象超出了范围，python垃圾收集器在我可以在C++端使用它之前销毁了我的对象。
为了避免销毁，我在绑定代码中添加了一个"keep“方法来增加ref_count，这样python垃圾收集器就不会销毁它了。
绑定的C++代码
VNCS::Real VNCS::py::BlendingField::blending(const VNCS::Point_3 &p) const
{
std::array<double, 3>
浏览 3提问于2020-11-03得票数 2
我一直在为gem5缓存实现一个自定义替换策略。我遵循DuelingRP的模型，包括参数的初始化。但是，当我尝试用scon构建gem5时，它在链接阶段失败，出现以下错误。
/usr/bin/ld: build/X86/python/_m5/param_TSelRP.o: in function void pybind11::cpp_function::initialize<pybind11::cpp_function::initialize<gem5::replacement_policy::TSel*, gem5::TSelRPParams, , pybind11::name, p
浏览 13提问于2022-06-04得票数 0
1回答
我试图用pybind11绑定静态重载函数，但遇到了一些问题。
下面是示例代码
#include <pybind11/pybind11.h>
namespace py = pybind11;
class TESTDB {
public:
static void aaaa(int a, int b) {printf("aaaaa");};
static void aaaa(int a) {printf("xxxxx");};
};
PYBIND11_MODULE(example, m) {
py::class_<T
浏览 2提问于2019-04-10得票数 0
回答已采纳
我有一个多继承结合蹦床的编译问题。下面的代码解释了这个问题：
#include <pybind11/pybind11.h>
#include <memory>
namespace py = pybind11;
// classes
class A {
public:
virtual int fA() const = 0;
};
class B : public A, public std::enable_shared_from_this< B > {
public:
int fA() const override {return 1;}
浏览 2提问于2021-09-16得票数 1
回答已采纳
1回答
在C++中通过PyBind11嵌入python时，我遇到了以下问题。假设我通过shared_ptr生成一个对象的C++实例，然后我希望将这个指针切换到pybind11，以便为它生成一个“影子”python绑定。
这是我最初的、不工作的尝试：
#include <stdio.h>
#include <pybind11/pybind11.h>
#include <pybind11/embed.h>
using namespace std;
namespace py = pybind11;
class Pet
{
public:
Pet() {}
浏览 0提问于2019-10-08得票数 3
1回答
我想在Pybind11中包装模板类函数的共享指针。我的类是一个模板队列：MyQueue.hpp
template<typename Data>
class MyQueue {
public:
std::queue <Data> the_queue;
static std::shared_ptr<MyQueue<Data>> make_data_q_ptr();
};
MyQueue.cpp
template<typename Data>
std::shared_ptr<MyQueue<
浏览 10提问于2022-07-19得票数 1
回答已采纳
我将pybind11用作C++代码的包装器，并将其放入python库。
碰巧有一些参数我无法提供，有时我希望在C++端执行我所知道的转换/初始化。例如，这可能是因为类在python中并不为人所知。这是怎么做到的？到目前为止，我看到的唯一“解决方案”是在C++中创建继承的代理类。
示例:我想定义/绑定python类A：
class A:
def __init__(self, B b):
...
具有一个C++等效类：
class A {
A(C c, D d);
}
是否有某种类型的lambda或类似的，我可以为pybind11::init<>创建？
浏览 1提问于2020-06-10得票数 4
回答已采纳
C++中是否有指向由他人管理的资源的智能指针？我正在使用pybind11包装C++代码，如下所示。
class B {};
class A {
public:
// original C++ class interface
A(std::shared_ptr<B> pb) : mb(pb){}
// have to add this for pybind11, since pybind11 doesn't take shared_ptr as argument.
A(B * pb):
浏览 0提问于2018-12-14得票数 2
回答已采纳
1回答
我有以下类结构(我的实际实现的简化示例)：
/* TestClass.hpp */
#pragma once
template <class Impl>
class CurRecTemplate {
protected:
CurRecTemplate() {}
~CurRecTemplate() {}
Impl& impl() { return static_cast<Impl&>(*this); }
const Impl& impl() const { return static_cast<const
浏览 1提问于2018-06-27得票数 0
回答已采纳
3回答
我正在尝试使用pybind11创建一个python绑定，该绑定引用一个在C++端处理内存的C++实例。下面是一些示例代码：
import <pybind11/pybind11>
struct Dog {
void bark() { printf("Bark!\n"); }
};
int main()
{
auto dog = new Dog;
Py_Initialize();
initexample(); // Initialize the example python module for import
// TBD - Add b
浏览 5提问于2016-10-05得票数 3
我有一个成员变量，它存储std::shared_ptr of std::vector<uint32_t>。我想为test_func2()创建一个Python，这样我就可以访问这个向量而不需要任何额外的副本。这是一个骨架代码。
#include <vector>
#include <memory>
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <pybind11/numpy.h>
namespace py = pybind11;
c
浏览 28提问于2022-01-31得票数 2
回答已采纳
我一直在尝试在一个C++程序中转换一个抽象类，尝试了与这个网页和官方文档不同的解决方案，例如和，但都不起作用。我的C++抽象类是：
class Base
{
public:
virtual ~Base(){};
virtual void foo(){};
};
我要导入到python的包装器是：
class BasePy: public Base
{
public:
void foo() override
{
PYBIND11_OVERLOAD_PURE(
void,
B
浏览 3提问于2020-05-15得票数 0
2回答
我遇到了一个问题，一个使用pybind11从c++基类派生的python类正在被立即析构(垃圾回收)。我希望C++获得动态分配的对象的所有权，但我似乎无法做到这一点。我尝试过keep_alive，将shared_ptr<>作为py::class_模板参数传递，而py::return_value_policy...什么都不起作用。我怀疑这只是用户的错误。
这是我遇到的实际问题的一个简化，我有一个更大的代码库，它的架构类似。改变架构不是一个选择，所以让这个示例工作对我来说至关重要。
我已经为使用pybind11创建了两个c++接口。类A和B都有虚方法，所以它们都有相应的trampoli
浏览 43提问于2018-02-27得票数 4
回答已采纳
简介：
这个问题是针对使用C++库将pybind11与python连接起来的。问题是包装C++类，这些类涉及多重继承，并在python中使用用户定义的holder类型(而不是unique_ptr或shared_ptr)。
问题：
假设有两个纯抽象接口类A和B，它们分别声明foo()和bar()纯抽象方法。类C公开继承A和B，并实现foo()和bar()<code>E 217</code>。类MyHolder是一个自定义的、不拥有智能指针的指针，类似于原始指针，但不实现指针算术和其他操作符以确保安全。
另外，A和B封装在MyHolder中有两个函数。代码在C++中按预期工
浏览 1提问于2018-03-08得票数 3
1回答
我试图在person类中编写单例模式，这使我能够只为该类创建一个实例，并且我可以在程序中的任何地方使用它。
以下是全班学生：
// The declaration
class Person {
static unique_ptr<Person> instance;
Person() = default;
Person(Person&) = delete;
Person& operator=(const Person&) = delete;
~Person() = default;
public:
static
浏览 0提问于2018-05-04得票数 0
回答已采纳
我使用pybind11来让python调用现有的C++模块(库)。但是，连接是通过C++库中的::GetModuleFileName (Visual )调用的，以确定在C++中运行的加载模块的物理路径。但是，当我通过pybind11从python (木星笔记本)调用库时，python.exe的物理路径将被返回。如何配置或更改以确保获得C++库的物理路径？
C++代码如下所示: Lib.h
#pragma once
void run();
Lib.cpp
#include <fstream>
#include <stdexcept>
#include <wind
浏览 9提问于2021-12-13得票数 0
回答已采纳
假设我定义了两个类(Foo和Bar)。Bar将两个Foo存储在std::vector中，作为std::shared_ptr，我希望通过使用pybind11将所有内容公开给pybind11。此外，我希望Foo也支持动态属性，这需要在绑定阶段使用pybind11::dynamic_attr()。只要我不试图只通过存储动态属性的向量向Foo实例添加动态属性，一切都可以正常工作。由于用语言解释我的问题并不容易，这里有一个MWE：
pybind11模块在pyissue.cpp文件中定义：
#include <pybind11/pybind11.h>
#include <pybind11
浏览 1提问于2019-10-01得票数 3
回答已采纳
我有一个C++类RuleSet，它有一堆std::shared_ptr，用于一场比赛的规则，最值得注意的是胜利的条件，一个std::shared_ptr<VictoryRule>。VictoryRule是一种抽象的C++类型，只有一个函数winners来返回游戏的胜利者。(team_t是一个枚举，但为了简单起见，可以将它作为int的别名。)
class VictoryRule {
public:
//! @brief Check if game is won by a team.
//! @return the teamno of the team that won or
浏览 12提问于2022-08-06得票数 0
回答已采纳
3回答
派生类和智能指针
、、、
class Object { /* */ };
和一些派生出来的：
class Derived1 : public Object { /* */ };
class Derived2 : public Object { /* */ };
我有一个函数，它生成派生对象并返回Object的指针；
Object *make()
{
return new Derived1();
}
所以，这样我必须用智能指针包装返回的对象，但是使用什么返回类型呢？
TYPE? make()
{
return boost::shared_ptr<Derived1>(new Derived1());
浏览 5提问于2010-12-29得票数 2
回答已采纳
1回答
我正在尝试使用pybind11来绑定一个结构，如下所示 struct myStruct {
int na;
int nb;
double* a;
double* b;
} 我不确定做这件事的正确方法。pybind11 documentation中的示例展示了如何将buffer协议语义附加到对象，而不是附加到类成员。 我也不能奢侈地更改myStruct的接口来包含std::vectors，这样我就可以使用通常的.def_readwrite()了。 我试过这样做 py::class_<myStruct>(m, "myStruct")
.def_prop
浏览 14提问于2019-09-04得票数 2
2回答
我有一个类似于下面的类结构，其中我有两个类型A和B，它们具有相似的签名，只是参数/返回类型不同。然后，我使用一个类模板来处理这两个类，在Python中实现了一个静态的鸭子类型变体。现在，我想用pybind11将这段代码封装到Python中，我希望得到一个使用标准的动态鸭子类型来接受这两种类型的类。我该怎么做呢？
我基本上是在寻找一种方法来禁用pybind11中的严格类型检查，或者指定多个类型，以便同时接受TypeA和TypeB。按照下面示例的定义方式，只有TypeA通过检查。我也不能将A和B统一到一个基类中，因为有不同的函数签名。
#include <pybind11/pybind11.
浏览 37提问于2017-07-05得票数 7
我开始使用Pybind11了。我计划在一个复杂的项目中使用Pybind11向python公开c++结构，将有助于看到一个示例，演示如何使用以下结构公开从python填充数组：
template <typename T>
struct point;
template <typename T>
struct quaternion;
template <typename T>
struct point{
T _x, _y, _z;
};
template <typename T>
struct quaternion{
T _a, _b_i, _c
浏览 1提问于2020-06-17得票数 0
我有下面的示例代码，它获得一个py::list作为计算某些python代码的输出。
我想把它转换成一个std::vector<std::string>，但是我得到了一个错误：
从‘pybind11 11：：list’到非标量类型'std::vector<std::__cxx11::basic_string >的转换请求
根据
当包含附加的头文件pybind11/stl.h时，将自动启用pybind11/stl.h std::set<>/std::unordered_set<>、std::map<>/std::unor
浏览 10提问于2022-10-11得票数 0
回答已采纳
我一直在为毁灭者的命令而挣扎，但我无法真正理解。
假设我们有以下定义：
#include <memory>
#include <iostream>
class DummyClass {
std::string name;
public:
DummyClass(std::string name) : name(name) { std::cout << "DummyClass(" << name << ")" << std::endl; }
~DummyClass()
浏览 1提问于2017-10-16得票数 3
1回答
常量构造函数
、、
是否有可能在C++中实现只允许创建const对象的构造函数？
我正在考虑用const和非const方法为接口创建一个装饰器类。从const基对象初始化装饰器应该只能产生常量装饰器，但是从非常量初始化应该产生全功能的装饰器。
struct A
{
virtual void foo(); // requires non-const A
virtual void bar() const; // const method
};
class decorator : public A
{
private:
std::shared_ptr<A> p_
浏览 0提问于2015-05-13得票数 3
以下代码无法在VisualC++ 11中编译，出现此错误：
1>c:\users\tony\documents\visual studio 11\projects\cpp11_ex1\cpp11_ex1\main.cpp(52)：错误C2440：'‘：无法从'Foo *const’转换为'std::weak_ptr<_Ty>‘
#include <stdio.h>
#include <memory>
using namespace std;
class Foo;
class Bar
{
public:
Bar(
浏览 4提问于2011-09-21得票数 2
回答已采纳
3回答
下面的代码可以在Visual Studio中编译，但在gcc中编译失败。
template<typename Isth>
class A
{
public:
A(const boost::shared_ptr<Isth>& obj) {...}
...
};
在类B的方法中：
A<Isth1> B::method1
{
boost::shared_ptr<Isth2> myPtr = boost::make_shared<Isth2>();
//Isth2 is derived from Isth1;
浏览 1提问于2015-11-19得票数 1
我有一个聪明的指针列表。我希望这些智能指针中的一些充当常规指针，这意味着它们只是对实例的引用，而不涉及实例的释放。例如，它们可能指向堆栈上分配的实例。列表中的其他智能指针应充当常规boost::shared_ptr。
下面是这个类的外观：
template<class T> smart_ptr {
private:
T *p;
boost::shared_ptr<T> sp;
public:
smart_ptr(T *p): p(p), shared(0) { } // p will not be deleted
smart_ptr(bo
浏览 2提问于2009-07-20得票数 4
回答已采纳
我创建了.pyd文件： #include <pybind11/pybind11.h>
#include <iostream>
#include <typeinfo>
namespace py = pybind11;
int add(int num) {
float a = 1.0;
for (int i = 0; i <= num; i = i + 1) {
a = (a + i)/a;
}
std::cout << "dll is typing: " &
浏览 23提问于2020-08-01得票数 1
回答已采纳
1回答
我试图在PyBind11中处理朋友类中的指针。问题是，我无法在Python中检索朋友类对象的指向值。玩具的例子起作用了，但是它们的价值和它们应该是完全不同的。
我起初以为是因为朋友班的缘故，但根据我的阅读和理解，我不认为是这样。我也没能在中找到任何东西。
example.cpp
#include <pybind11/pybind11.h>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <list>
浏览 0提问于2020-04-10得票数 0
回答已采纳
我想保持std::shared_ptr的聪明行为。那么，是否有一种方法可以在不混淆引用计数的情况下将共享的空指针转换为另一种类型？我无法获得原始指针并从中创建一个新的共享指针。
浏览 6提问于2014-09-16得票数 21
回答已采纳
我有一个“接口”作为.h文件，该文件具有如下所示的虚拟方法：
class ISomeInterface {
public:
virtual std::shared_ptr<Parent> getX() = 0;
}
现在，父类是“抽象的”，在接口的实现者中，我使用了一个实际的类。所以我想这么做：
class Implementor : public ISomeInterface {
public:
std::shared_ptr<Child> getX() = { return this->x; }
}
但我得到了：
浏览 14提问于2017-03-30得票数 2
回答已采纳
我在c++中有一个类，它用pybind11包装成python。该类有一个std：：函数，我想控制如何处理该函数的参数(比如返回值策略)。我只是找不到语法或例子来做这个.
class N {
public:
using CallbackType = std::function<void(const OtherClass*)>;
N(CallbackType callback): callback(callback) { }
CallbackType callback;
void doit() {
OtherClass * o = new Othe
浏览 4提问于2020-02-07得票数 1
回答已采纳
#include <pybind11/pybind11.h>
#include <Python.h>
#include <iostream>
#include <arrow/python/pyarrow.h>
#include <arrow/table.h>
// Convert pyarrow table to native C++ object and print its contents
void print_table(PyObject* py_table)
{
// convert pyobject to tabl
浏览 21提问于2022-01-07得票数 2
在我的仿真软件中，我使用pybind11生成对象。因此，在编译时，所有对象都以未知的结构存储在std::shared_ptr中。为了并行化我的模拟，我需要运行相同的配置与不同的种子。我想在C++端的一个调用中实现这些对象的复制。
下面是一个很小的例子，其中我希望a2成为a的深拷贝，具有菱形结构。
// Type your code here, or load an example.
#include <memory>
#include <map>
#include <iostream>
class C{};
class B{
public:
浏览 4提问于2022-07-13得票数 -1
回答已采纳
1回答
错误:函数参数不兼容
、、、
我正在使用pybind11访问一些我在python中用C++编写的函数。我希望将一个初始化的结构实例返回给python (从一个类成员函数)，这样我就可以访问python中的实例值。我已经提供了我的源文件的简化版本。你可以用下面的代码重现错误。这是c++包装器
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include "sum.h"
namespace py = pybind11;
PYBIND11_PLUGIN(GetSum) {
py::module mod("Ge
浏览 4提问于2017-08-09得票数 2
下面是example.cpp代码： #include <pybind11/pybind11.h>
namespace py = pybind11;
int add(int i, int j) {
return i + j;
}
class mycl{
public:
mycl(){};
mycl(int a){
age = a;
};
void call(){
printf("I'm here!\n");
}
int ask_age(){
prin
浏览 37提问于2020-09-16得票数 0
回答已采纳
3回答
C++向量半常数
、、
我希望从具有以下属性的方法返回一个std::vector：接收方(用户)将能够编辑向量中的元素，但不能更改向量本身(调整大小、删除、添加等)。
如果我返回一个std::vector<T>&，接收方将能够调整它的大小，向它添加元素，等等。
如果我返回一个std::vector<T> const& (我声明了对吗？)，它们将无法更改元素。
如果我返回std::vector<T>，它将是一个全新的向量，对元素的更改不会出现在原来的向量中。
有办法这样做吗？也许是一位推荐人，作为康斯特(std::vector<T&&
浏览 2提问于2012-10-31得票数 2
我有许多从纯virtal基础派生的类：
class base {
public:
virtual int f() = 0;
};
class derived_0 : public base {
public:
int f() {return 0;}
};
class derived_1 : public base {
public:
int f() {return 1;}
};
为了简洁起见，我只放了两个派生类，但实际上我有更多的派生类。
我想创建一个拥有指向基类的const共享指针的类。我想做以下事情，但我不能，因为我必须初始化初始化列表中的常量指针：
class
浏览 0提问于2011-11-03得票数 2
回答已采纳
我正在处理一个SystemC项目，我想使用PyBind11在其中添加python绑定，并且我一直在遵循站点上的文档来编写绑定。
我正在使用CMake构建我的项目，我面临的挑战是我需要将我的C++代码链接到SystemC和PyBind11。这是我的CMakeLists当前的样子：
project(simple_fifo_python)
cmake_minimum_required(VERSION 3.0)
find_package(pybind11 CONFIG REQUIRED)
message(STATUS "Found pybind11 v${pybind11_VERSION}:
浏览 8提问于2018-11-19得票数 0
4回答
我尝试在删除器中使用std::shared_pointer。我尝试使用一个成员函数作为删除器。然而，它无法编译。编译器给了我一条错误消息，但我不明白为什么它不能工作。有人知道它为什么不起作用吗？非常感谢。
简化代码如下，
#include <memory>
class MemberFunctionPointerInConstructor {
public:
MemberFunctionPointerInConstructor(void) {
std::shared_ptr<int> a = std::shared_ptr<int>(
浏览 7提问于2016-03-04得票数 7
回答已采纳
假设我们有一秒钟
#include <boost/shared_ptr.hpp>
#include <iostream>
int main()
{
boost::shared_ptr<int> bleah(); //default constructor
cout << bleah.get() << endl; //error line
boost::shared_ptr<int> barf(new int (10));
cout << *barf.get() << end
浏览 1提问于2011-11-04得票数 0
回答已采纳
这将是一个更开放的问题，但我希望有人可能知道如何解决我的问题。
我有用pybind11编译的C++库，允许我从python中调用一些函数。C++库使用CUDA在设备上执行一些操作。
我需要允许用户(只能访问python，不能进入C++或CUDA代码)定义将在某个CUDA内核中运行的操作(通常是lambda)。
如果你有任何建议，告诉我在哪里可以学到正确的方法，我将不胜感激！
浏览 0提问于2020-10-26得票数 0
我有一个C++应用程序，我试图使用pybind11来支持我的应用程序中的脚本系统，这样用户就可以编写自己的脚本了。我试图使用Python，就像许多人使用Lua作为脚本语言来扩展应用程序的功能一样。
在Lua /pybind11方面，我发现了一个很大的不同:使用Lua，我可以静态地将脚本语言链接到我的可执行文件中，甚至可以打包一个共享库，但是使用Python/pybind11，我似乎依赖于最终用户是否已经在他们的系统上安装了Python。
对吗？
有什么方法可以让pybind11静态地链接Python库吗？
pybind11似乎还会搜索python可执行文件的路径，然后假设共享库位于同一个文件夹
浏览 10提问于2022-06-14得票数 0
有一个关于“模块析构函数”的部分。如何用pybind11实现“模块构造函数”？
假设我想在用Python导入模块时执行C++函数。通常，如果这是一个Python模块，我只需将带有函数调用的命令添加到module.py的顶级作用域中。这是在Python模块中可以做的最基本的事情--执行命令。但是pybind11 11的从添加函数定义开始。如何向pybind11模块添加命令？
浏览 3提问于2020-11-02得票数 0
回答已采纳
2回答
#include <memory>
class Base
{
std::shared_ptr<Base> create() const; // Returns a default constructed object
}
假设从Base派生的所有成员在任何程度上都是可复制构造和默认可构造的。我想要
std::shared_ptr<Base> create() const;
方法来创建适当动态类型的对象，但我不想使用样板代码。
有没有可能让
std::shared_ptr<Base> create() const;
静态绑定，但内部以某种
浏览 0提问于2012-07-21得票数 2
回答已采纳
铁锈相当于C++的this是self。在铁锈中，您可以这样做：
struct C;
impl C {
fn some_fn(self: &Rc<Self>) {}
}
这种特性是否存在于C++中？以下内容在语法上无效：
class c_t {
void some_fn(std::shared_ptr<c_t> this) {
std::cout << "calling from shared_ptr";
}
};
这样我就能做到：
auto c = std::make_shared<c_
浏览 4提问于2022-03-07得票数 -1
回答已采纳
1回答
我有以下设置(一个基类，一个派生类，一个容器)。容器接受一个shared_ptr<Base>作为输入。
#include <pybind11/pybind11.h>
namespace py = pybind11;
struct Base { };
struct Derived : public Base { };
struct Container { void input(const std::shared_ptr<Base>& ptr) { } };
PYBIND11_MODULE(PybindTest, m)
{
py::clas
浏览 4提问于2019-02-22得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
云直播活动推荐
腾讯云开发者
