如何使用std::make_shared创建基类类型的智能指针？
使用std::make_shared创建基类类型的智能指针可以通过以下步骤实现：
- 首先，确保你的代码中包含了<memory>头文件，该头文件提供了智能指针的相关功能。
- 定义一个基类类型的指针，例如BaseClass* ptr。
- 使用std::make_shared函数创建一个基类类型的智能指针，将指针作为参数传递给该函数。例如，使用以下代码创建一个名为sharedPtr的智能指针：
- 使用std::make_shared函数创建一个基类类型的智能指针，将指针作为参数传递给该函数。例如，使用以下代码创建一个名为sharedPtr的智能指针：
- 这将创建一个指向BaseClass对象的智能指针，并自动管理对象的生命周期。
- 注意：std::make_shared函数会自动分配内存并构造对象，因此不需要手动调用new操作符。
- 现在，你可以使用sharedPtr智能指针来访问基类对象的成员函数和成员变量，就像使用原始指针一样。例如，可以使用以下代码调用基类对象的成员函数：
- 现在，你可以使用sharedPtr智能指针来访问基类对象的成员函数和成员变量，就像使用原始指针一样。例如，可以使用以下代码调用基类对象的成员函数：
- 这将调用BaseClass的memberFunction函数。
使用std::make_shared创建基类类型的智能指针的优势是：
- 方便：std::make_shared函数将内存分配和对象构造组合在一起，简化了代码编写过程。
- 安全：智能指针会自动管理对象的生命周期，避免了内存泄漏和悬空指针的问题。
- 高效：std::make_shared函数使用了内存池技术，可以减少内存分配和释放的开销，提高程序的性能。
基于上述描述，腾讯云提供了云原生计算服务，该服务为用户提供了一种高效、安全、可靠的云计算环境，用户可以在云原生计算环境中使用std::make_shared创建基类类型的智能指针。具体产品介绍和相关链接地址请参考腾讯云云原生计算服务官方文档：云原生计算服务。
相关·内容
我有一个向量，它包含一组共享指针：
std::vector<std::shared_ptr<Derived>> originalVector;
在某种程度上，它被抛到Base共享指针中，它看起来如下：
std::vector<std::shared_ptr<Base>>* castedVector = reinterpret_cast<std::vector<std::shared_ptr<Base>>*>(&originalVector);
如何将Derived项添加到浇铸向量中？显然，我可以在它中放
浏览 0提问于2019-04-02得票数 0
我开始使用C++0X/11中的智能指针，并且遇到了一个特殊的情况。我希望使用shared_ptr对对象的实例进行强制转换。
类扩展继承了类库，其中基类有一个虚拟析构函数以使其多态(否则dynamic_pointer_cast会抱怨非多态类转换)。
因此，如果：
std::shared_ptr<Base> obj = std::make_shared<Base>();
然后我做了：
obj = std::dynamic_pointer_cast<Extend>(obj);
安全吗？
对象的其他指针会发生什么呢？只是obj将其视为扩展，而其他共享指针仍将
浏览 5提问于2013-02-14得票数 10
回答已采纳
1回答
我有一个从基类派生的类，它有一个嵌套类。我希望在派生类中覆盖嵌套类的成员函数，并重写基类的成员函数。(如下所示)
我找到了一个解决方案()，它通过创建另一个从基类嵌套类继承的嵌套类来工作。但是，在创建这个新嵌套类的实例时，我会得到另一个返回类型，这对我没有帮助，因为我想重写的函数返回一个基类的嵌套对象，但是应该访问嵌套的重写函数。
该设置的代码示例如下所示：
class Base {
public:
class Nested {
friend class Derived;
public:
virtual void funcNested() { std::cout &l
浏览 4提问于2022-08-31得票数 1
回答已采纳
3回答
由于我是面向对象编程的初学者，所以提前向您道歉。
我有一个名为Hero的基类，有三个派生类: Archer、Warrior和Mage。提示用户选择其中之一，并创建相应派生类的对象。它们有不同的初始值和成员函数，下一步是将这个对象传递给另一个函数。
假设函数名为say ()，它将对象作为参数。我该怎么做呢？我必须创建三个单独的way ()，还是有一种无需指定派生类就可以传递对象的方法？
void Hero::init(string job)
{
if (job == "archer")
Archer archer;
else if (job =
浏览 4提问于2014-06-08得票数 0
回答已采纳
1回答
我想要创建一个图形对象，当我沿着它绘制时，它可以在以下不同的数学函数之间切换。目前，我将当前的数学函数作为一个对象保存在图形对象中，所以当我调用它的绘图函数时，它知道应该遵循什么，并且试图使用多态性来描述不同类型的数学函数。我的当前(不工作)代码如下所示：
#pragma once
#include<array>
class MathExpression
{
public:
virtual ~MathExpression() = default;
virtual MathExpression integrate() const = 0;
};
class Pol
浏览 1提问于2021-12-23得票数 0
回答已采纳
1回答
class Base {
public:
virtual void f() const { std::cout << "Base::f()" << std::endl; }
};
class Derived : public Base {
public:
void f() const { std::cout << "Derived::f()" << std::endl; }
};
int main()
{
Base* obj = new Derived;
std::shared_
浏览 2提问于2022-01-22得票数 0
回答已采纳
3回答
我打算有一个构造函数来接受引用，然后创建指向作为引用传递的对象的指针，并将这些指针存储在字段中。但是，由于某种原因，复制正在被创建，我不明白为什么：
#include <iostream>
#include <vector>
#include <memory>
// the class with the field of pointers
template<class T, class... Types>
class C
{
private:
std::vector<std::shared_ptr<T>> me
浏览 6提问于2017-08-07得票数 2
回答已采纳
我试图向数组中添加不同类型的对象，并希望在转换之前获得派生类的类型。有很好的解决办法吗？
顺便说一句:这个例子行不通。当我检查对象时，类型设置不正确。
伪码：
enum Fruit {
APPLE = 0,
BANANA = 1
}
class Fruit {
public:
int type;
}
class Apple : Fruit {
...
}
class Banana : Fruit {
...
}
Apple *apple = new Apple();
apple->type = APPLE;
vector<Fruit*> f
浏览 0提问于2018-10-04得票数 0
回答已采纳
2回答
我看了这个页面，关于shared_pointer的实现。
有一条这样的线路-
boost::shared_ptr<Exercise> americanExercise(new AmericanExercise(settlementDate, in.maturity));
我了解到，使用这一行，我们基本上创建了一个名称shared pointer americanExercise，它指向类Exercise的一个对象。
但是我想知道如何用make_shared重写这一行，因为make_shared是定义指针的更有效的方法。下面是我的尝试-
shared_ptr<Exercise&
浏览 10提问于2020-09-17得票数 0
回答已采纳
我还没有发现像这样的问题:但是如果有人发现了问题，那就道歉。我一直试图使用std::shared_ptr来极大地简化内存管理，但是我遇到了一定是某种错误。
当我用DerivedType创建一个std::make_shared<type>(DerivedType(...))指针时，它只能被称为Type而不是DerivedType。
然而，当我使用语法std::shared_ptr<Type>(new DerivedType)时，vfptr表列出了正确的条目，并且可以在没有问题的情况下将其转换为DerivedType。
我认为应该没有什么不同。在我看来，这是个错误吗？还是一
浏览 1提问于2015-02-13得票数 0
回答已采纳
1回答
我是C++的新手，我还在学习如何编写干净的代码。 下面是我现有的遗留代码的摘录。 class A {
public:
setDataManager(dm)
{
_dm = dm;
}
void recieveData(data)
{
_dm.processData(data);
}
private:
std::shared_ptr<DataManager> _dm;
};
class DataManager {
public:
void processData(data)
浏览 24提问于2020-08-19得票数 0
回答已采纳
使用原始指针，我可以创建一个指针和push_back地址的向量，如下所示：
Entity objEntity;
std::vector<Entity*> Entities;
Entities.push_back(&objEntity);
如果我使用共享指针的向量：
std::vector<std::shared_ptr<Entity>> Entities;
..。我如何push_back地址？
据我所知，使用std::shared_ptr::reset是为了将现有对象的地址分配给智能指针。我需要先创建一个临时指针，然后调用reset，然后是push_
浏览 0提问于2018-07-02得票数 3
回答已采纳
1回答
我一直在创建命名变量，以便能够将它们的入口传递给期望指针的构造函数，但我希望能够在构造函数或其他函数中创建它们，然后将它们的地址传递给期望指针的构造函数。
我使用的是C++ 20，我有以下类：
#include <iostream>
#include <string>
#include <vector>
#include <random>
using std::string, std::cout, std::cin, std::endl, std::vector;
class symbol {
public:
enum symbolK
浏览 1提问于2022-02-08得票数 0
回答已采纳
我想持有一个模板类的shared_ptr。但是，我也不想把B类作为模板类。据我理解，任何类型的shared_ptr都将具有相同的内存布局。所以我想知道在这种情况下有什么解决办法吗？
template<T>
class A {
...
};
class B {
...
std::shared_ptr<A<T>> ptr;
}
浏览 0提问于2020-08-17得票数 3
回答已采纳
我有这个基类
struct Expr
{
virtual void accept(std::shared_ptr<const Expr> &expr, ExprVisitor &visitor) = 0;
explicit Expr() = default;
virtual ~Expr() = default;
};
和一些子类，例如：
struct Binary : Expr
{
explicit Binary(Expr &left, Token &_operator, Expr &right);
浏览 1提问于2020-04-22得票数 0
1回答
如何创建既包含基类又包含任何派生类的向量？
例如，在一个国际象棋引擎中，我目前有一个Move类，它存储了一个特定的走法和一些函数来帮助它。为了节省内存，因为要创建数百万个这样的对象，我还有一个扩展了Move类的派生类CaptureMove，它存储了更多关于捕获的内容和位置的信息。
据我所知，指向Move对象的指针应该可以工作，但我不太确定如何去做。
浏览 0提问于2015-08-01得票数 0
3回答
我有一个包含Event类的对象的队列。
std::priority_queue<Event> events;
但Event只是实际事件的超类。让我们假设我们有以下类：
class Event{
public:
void Action(){
std::cout<<"do nothing"<<std::endl;
}
};
class XEvent : public Event{
public:
void Action(){
std::cout<<
浏览 0提问于2016-04-29得票数 0
注意，在这个示例中，我创建了一个派生类指针(激光* pLaser =新激光)，而不是类似于基类指针(Boat* pLaser =新激光)。创建基类指针有什么好处吗？谢谢!
#include <iostream>
using namespace std;
class Boat
{
protected:
int length;
public:
int getLength() { return length; }
virtual void Model() =
浏览 1提问于2020-05-23得票数 0
回答已采纳
我有一个class MyClass，它应该能够返回这个用QSharedPointer<MyClass>包装的。
根据我的理解(和经验)，简单地创建QSharedPointer<MyClass>(this)的新实例并不是一条路。相反，实现我想要的结果的正确方法是让MyClass从继承来提供成员函数sharedFromThis()。
这个成员函数应该返回，这个封装在QSharedPointer<MyClass>中，而不会出现所有的不良副作用。
class MyClass : public QEnableSharedFromThis<MyClass>
浏览 3提问于2017-12-10得票数 0
1回答
我有一个名为Item的基类
#ifndef ITEM_H
#define ITEM_H
#include <ostream>
class Item {
public:
virtual ~Item() {}
virtual void print(std::ostream& out) const {}
friend std::ostream& operator << (std::ostream& out, Item& item){
item.print(out);
return out;
}
浏览 0提问于2011-12-04得票数 0
回答已采纳
2回答
class B;
class C;
class B
{
public:
B() { cout<<"B created"<<endl; }
~B() { cout<<"B destroyed"<<endl; }
shared_ptr<C*> ptrc;
};
class C
{
public:
C() { cout<<"C created"<<endl; }
~C() { cout<<"C
浏览 33提问于2021-06-18得票数 3
我在理解shared_ptr的造型时遇到了问题。很好地解释了使用普通指针的行为，结果非常直观--这正是我所期望的。然而，shared_ptr显示了不同的结果--我使用***_ptr_cast创建了3个类，一个基类和两个派生类
#include <iostream>
#include <memory>
using namespace std;
struct Base
{
virtual void f() { cout << "Base" << endl; }
string name = "Ba
浏览 3提问于2021-01-07得票数 0
误差
E/c++/v1/算法:642: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1/utility:321:9:错误：
字段类型'Space‘是一个抽象类_T2第二；^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1/map:624:16:注：
问题
如何定义一个类型为std::ve
浏览 0提问于2019-04-15得票数 0
3回答
我对这段代码有问题--这是taskData：
static std::map<int8_t, std::vector<Task>> taskData;
还有一个问题：
taskData.emplace(pi::enumerations::taskManager::taskCategory_t::SECURITY, std::vector<Task>{FirefightingTask()});
FirefightingTask：
#pragma once
#include "Task.hpp"
namespace mc
{
clas
浏览 3提问于2017-03-18得票数 2
1回答
为共享指针C++单独实例化对象
、、、、
下面的代码运行良好：
std::map<std::string,std::ofstream*> m_jsTabFilesMap;
m_jsTabFilesMap.insert({ listOfTabNames[i], new std::ofstream(jsFilename)});
但是，如果我将普通指针替换为共享指针，插入函数将报告不存在重载版本的函数insert()。
std::map<std::string, std::shared_ptr<std::ofstream>> m_jsTabFilesMap;
我该如何解决这个问题？这与我使用new实例化对
浏览 15提问于2017-08-18得票数 2
1回答
我有虚拟汽车。这个班有不同的子类。
在我的界面中，我有功能
ride(std::string type = "mercedes")
函数采用参数类型，并在此基础上决定实例化哪辆车并执行平顺性。目前，我所做的事情如下：
ride(std::string type = "mercedes")
{
if(type =="btw")
{
auto car = std::make_shared<BMW>();
car.ride();
}
else if(type =="audi")
{
auto car
浏览 0提问于2016-05-18得票数 1
回答已采纳
2回答
我正在尝试创建一个具有值语义的构建器类，如下所示
class Pipeline {
public:
Pipeline(
const std::string& name,
std::optional<size_t> limitIn,
std::optional<size_t> limitOut) {...}
shared_ptr<const Pipeline> limitInput(size limit) const {
return make_shared<Pipeline>(name
浏览 0提问于2020-05-26得票数 0
2回答
我有：
一个基础抽象类Shape.Then，--几个子类，其中一个是名为GeneralObject<T>的Rectangle.A模板类，具有一个私有成员T形状(T具有一个静态断言检查，用于检查它是否为形状的子类)，以便创建一个GeneralObject：GeneralObject<Rectangle>An ObjectManager，我想包含一个GeneralObject(s).的向量。
如何实现此功能才能使模板类的向量具有任意形状？
我认为一种方法是从3)中删除静态断言并创建如下内容：
std::vector<GeneralObject <std::sha
浏览 3提问于2021-02-02得票数 1
回答已采纳
1回答
我正在使用openCV arUco标记来检测一些标记。所以我生成了预定义的字典，并将其保存在一个文件中。但是，aruco::detectMarkers只能获取Ptr<aruco::Dictionary>。因此，我创建了一个Ptr<aruco::Dictionary>对象，并将该对象本身的地址发送给构造函数。这会导致应用程序结束时出现异常。我该怎么解决它呢？
以下是我的(简化)代码：
#include <opencv2/highgui.hpp>
#include <opencv2/aruco/charuco.hpp>
#include <op
浏览 5提问于2021-05-18得票数 0
2回答
我有一个抽象类和两个具体的子类(Store)，它们都有一个指向另一个从抽象类(Factory)派生的具体子类的指针。下面是商店的代码。我想防止内存泄漏，所以我开始编写复制控制。我不能实例化一个新的Factory，因为我不知道它会是什么类型。什么是规避这一问题的好做法？我可以在具体的Stores中编写copy控件，但是我有重复的代码。我也尝试过使用智能指针，但我发现了另一个困难。代码片段myFactory = std::make_shared<AbstractFactory>(ConcreteFactoryA());显然首先创建一个AbstractFactory，然后用Concret
浏览 0提问于2012-07-16得票数 0
回答已采纳
3回答
我是C++的初学者，对于这个游戏项目，我想要创建的是一个通用的"GameObject“元素的集合，每个元素都有更新的虚方法，Draw...then有继承它的类，这样当更新世界时，我只需要保持一个集合循环通过...
使用矢量来保存抽象类的集合似乎是不可能的，我尝试保持Draw和Update方法为虚的，但是如果我创建一个Enemy : public GameObject实例并将其添加到Vector<GameObject>并调用update，我就会得到各种各样的链接器:未定义的符号错误...
我不知道，有件事我不明白...我确信这是许多应用程序都需要的一种设置……你对此有什么建议
浏览 2提问于2011-11-06得票数 1
现在，我对抽象类有了很好的理解，但是，我最近尝试使用一个抽象类来创建一个虚拟函数来接收消息，然后使用另一个类创建一个智能指针指向该类的std::vector，但是我得到了错误C2259。(是的，我查过了)
边注：
最近，我还阅读了大量关于智能指针的内容，因为它们几乎(如果不是总是)在每个与指针相关的问题中都会被提到。所以我决定第一次尝试实现它们，所以我的问题可能实际上是因为我不正确地使用智能指针。
不管怎么说，这是纯抽象类本身--
//Component.h
namespace rpg
{
class Component
{
public:
virtual void Receive
浏览 5提问于2014-07-19得票数 0
回答已采纳
我试着寻找答案，但找不到任何帮助我理解幕后所发生的事情的东西。
假设我们有以下情况：
class Base
{
public:
virtual int request() = 0;
void* operator new(long unsigned int size) = delete;
};
class Derived final : public Base
{
public:
int request() override;
};
int Derived::request()
{
return 2;
}
在基类上，我删除了新操作符，因为我不想创建指针。我
浏览 0提问于2018-12-03得票数 8
回答已采纳
2回答
我想知道在下面的例子中使用指针向量的优点是什么。这三个向量在内存管理方面有什么不同吗？哪一种最有效？
class foo{
public:
foo(int a);
private:
int x;
};
foo::foo(int a){
}
int main() {
std::vector< std::shared_ptr<foo> > vec =
{std::make_shared<foo>(2), std::make_shared<foo>(2)};
std:
浏览 3提问于2014-12-06得票数 0
回答已采纳
3回答
为这个冗长的问题道歉，但有些上下文是必要的。对于我正在从事的项目，我有一些代码似乎是一个有用的模式：
class Foo
{
public:
Foo( int bar = 1 );
~Foo();
typedef std::shared_ptr< Foo > pointer_type;
static pointer_type make( int bar = 1 )
{
return std::make_shared< Foo >( bar );
}
...
}
如您所见，它提供了一种简单的方法，可以将任何
浏览 3提问于2016-03-12得票数 7
3回答
智能指针上的模板推导/替换失败
、、、、
让我们考虑一下这段代码： template<typename T>
struct A
{
//...
};
struct B : public A<int>
{
//...
};
template<typename T>
bool validate(A<T>* p)
{
//...
return true;
};
int main()
{
A<int>* pA;
std::cout << validate(pA) << std::endl;
B* pB;
std::co
浏览 7提问于2020-04-30得票数 4
假设DoSomething方法是接口的实现。我不能改变它的签名。DoSomething如何使用第二个构造函数实例化MyClass2并提供一个指向当前MyClass实例(而不是副本)的智能指针？
#include <Windows.h>
#include <iostream>
class MyClass;
class MyClass2 {
public:
std::shared_ptr<MyClass> ptr;
MyClass2() {
ptr = nullptr;
}
MyClass2(std::shared_ptr<
浏览 0提问于2021-09-24得票数 1
回答已采纳
5回答
智能指针数组的正确初始化
、、、
在这种情况下：
class A
{
//implementation
};
class B
{
public:
B();
~B();
private:
std::vector<std::shared_ptr<A>> _innerArray;
};
我应该如何在B()中创建一个具有有效状态的对象？是否需要手动调用数组中每个A对象的默认构造函数？我需要在~B()中做一些特别的事情吗？如果B类是糟糕设计的例子，可以说如何使它更好。谢谢。
编
浏览 23提问于2012-11-07得票数 5
回答已采纳
1回答
class Tool {
public:
virtual void mouseUp();
virtual void mouseDown();
virtual ~Tool();
};
class SelectionTool : public Tool {
void mouseDown() override {
std::cout << "SelectionTool icon\n";
}
void mouseUp() override {
std::cout << "
浏览 44提问于2021-09-29得票数 0
回答已采纳
2回答
假设我有一个基类和多个派生类，我希望避免为每个派生类类型设置多个变量/函数。
我发现唯一能意识到这一点的方法是耗尽/下播。但是，尤其是下风往往被认为是不好的做法-那么还有什么路要走呢？
示例：
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
class Animal{
protected:
Animal(std::string val) { name = val; }
public:
virtual ~Animal() = default;
std::string
浏览 8提问于2021-02-25得票数 1
回答已采纳
1回答
存储多类型对象的C++队列
、、、、
到目前为止，我最好的想法是使用一个基类并将它与不同类型的对象一起子类。在本例中，有两个具有类似方法的子类，因此这似乎是合乎逻辑的。我通过将对象向上转换到基类来存储对象，但是在使用它的子类方法访问对象时遇到了困难。以下是我的头文件和主要方法：
#include <iostream>
#include <queue>
#include <stdlib.h>
#include <string>
#include <sstream>
#define STATIC 0
#define DYNAMIC 1
// Base class Msg
浏览 0提问于2016-03-23得票数 1
回答已采纳
1回答
我正在尝试创建一个程序，让用户在屏幕上点击两次，并根据单击的内容绘制一个矩形。
现在，我所要做的就是将我的类设置为能够手动正确地绘制矩形，而不必担心用户单击的位置。
最终，我的程序将能够绘制像圆圈和三角形这样的东西，所以我决定使用多态性，并将每个形状类型(即Rectangle)作为自己的类，继承自一个名为Shapes的类。
然后，我有一个名为Game的类，它包含一个Shapes对象。
Shapes.h
#ifndef _shapes_h_
#define _shapes_h_
#include <vector>
#include "glut.h"
class Sh
浏览 2提问于2015-04-11得票数 0
回答已采纳
我需要创建一个指向std：：shared_ptr的向量，正确的语法是什么？
std::vector<uint8_t> mVector;
shared_ptr<std::vector<uint8_t>> mSharedPtr = &mVector;
上面的代码不能编译。
谢谢。
浏览 2提问于2014-11-04得票数 14
2回答
我有以下的类和类型：
class Object
{
protected:
long int id;
public:
Object(void);
~Object(void) {};
long int get_id(void);
};
typedef map<string, Object> obj_map;
然后我有了它的孩子：
class Image: public Object
{
private:
path full_path;
int x;
int y;
img image;
public:
Imag
浏览 5提问于2015-06-22得票数 0
回答已采纳
下面是我的示例代码。基类有一个A类的指针，使用new运算符从堆中分配内存。我明确地抛出了一个异常。因为我没有在*ptr上调用delete，所以new分配的内存不会被释放。既然对象没有被完全构造，我们如何释放内存呢？ #include <iostream>
using namespace std;
class A
{
public:
A()
{
cout<<"A::ctor"<<endl;
}
~A()
{
cout<<"A::Dctor&#
浏览 16提问于2019-03-21得票数 3
2回答
我希望能够有一个模板类型参数为空，这种情况下，类只是一个空的T，或U，或其他什么。我尝试这样做，将模板参数默认为一个简单的lambda：
template <typename U = decltype([]() {})>
在Visual 2019 16.9.3中，当我查询U的类型时，我没有得到正确的结果，但通过尝试在OnlineGDB上编译，我发现这可能无论如何都不应该编译，因为默认参数是定义一个新类型：
#include <iostream>
template <typename T, typename U = decltype([]() { }
浏览 0提问于2021-04-20得票数 0
回答已采纳
我有一个函数，它接受Base类型的共享指针，然后接受指向派生类型的std::dynamic_pointer_cast。但是，派生指针是NULL，我不知道为什么。我确保在我的基类中包含一个虚拟析构函数。我不想使用静态强制转换，因为这不能保证我的派生成员变量和函数被保留？
守则如下：
基类：
class Base
{
public:
mType get_type()
{
return msg_type;
}
void set_type(mType type)
{
msg_type = type;
}
vir
浏览 2提问于2015-09-01得票数 0
回答已采纳
7回答
参考代码：
#include <vector>
#include <iostream>
class Func {
public:
virtual void call() {
std::cout<< "Func -> call()" << std::endl;
}
};
class Foo : public Func {
public:
void call() {
std::cout<< "Foo -> call()" <<
浏览 1提问于2012-04-14得票数 7
回答已采纳
2回答
class SymbolNode {
public:
string name;
Type type;
int offset;
SymbolNode(string name_, Type type_, int offset_): name(name_), type(type_), offset(offset_) {
}
};
class FuncNode : public SymbolNode {
public:
Type returnType;
vector
浏览 4提问于2020-05-18得票数 0
1回答
我试图在C++中实现一个JSON框架，并希望使用多态概念。我有一个类JSONNode，它是一种容器，用于存储其他JSONNode对象本身，等等。我是用指针和动态分配来完成这个任务的。为了保证异常安全，我不想使用new/delete，而是使用boost共享指针。向json对象添加元素(进一步的json对象)的基本场景如下所示：
typedef boost::shared_ptr<JSONNode> JSONNodePtr;
void JSONNode::Add(JSONNodePtr nodePtr, const std::string& name)
{
th
浏览 4提问于2013-09-06得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
