25
4
I am a little confused with new smart pointers. I want to use one pointer to point at two different objects of sibling classes (same parent).
我对新的智能指针感到有点困惑。我想使用一个指针来指向兄弟类的两个不同对象(相同的父类)。
so basically I have a parent class Parent and two child classes Child1 and Child2
所以基本上我有一个父类Parent和两个子类Child1和Child2
个人中心
文章发布
退出class Parent{
virtual void foo() = 0;
};
class Child1 : public Parent{
void foo(){
//something
}
}
class Child2 : public Parent{
void foo(){
//something different
}
}
The pointer say ptr is first pointing at Child1 and then it should point at Child2
Doing so I want to use the same pointer to behave differently as per the implementations inside those sibling classes.
指针说Ptr首先指向Child1，然后它应该指向Child2，这样做，我希望使用相同的指针来表现与那些兄弟类中的实现不同的行为。
I think,Parent ptr = new Child1() a non smart pointers way, should work in this case if I do (Child2 *)ptr
我认为，父Ptr=new Child1()是一种非智能指针方式，如果我这样做(Child2*)Ptr，在这种情况下应该可以工作
But I am sure there would be a better way through smart pointers.
但我相信，通过聪明的指针会有更好的方法。
I know that reinterpret_ptr does have some usecase around this topic but i couldn't understand the explanation on gfg. ALSO my main Question is How do I declare this pointer?
我知道reinterpret_ptr在这个主题上确实有一些用处，但我不明白gfg上的解释。另外，我的主要问题是如何声明这个指针？
unique_ptr<Parent> ptr = make_unique<Child1>();?
UNIQUE_PTR
I think, Parent ptr = new Child1() a non smart pointers way, should work in this case if I do (Child2 *)ptr No it won't. ptr points to a Child1. There is no Child2. Don't cast it to one.
我认为，父Ptr=new Child1()是一种非智能指针方式，如果我这样做(Child2*)Ptr No它不会起作用。Ptr指向Child1。没有孩子2。别把它扔给一个人。
Your "non smart pointer way" is undefined behavior.
你的“非智能指针方式”是未定义的行为。
You cannot have a pointer to Child1 and pretend it's a pointer to Child2. Whatever casts you use, it's still wrong.
您不能将指向Child1的指针设为指向Child2的指针。不管你用什么石膏，它仍然是错误的。
"The pointer say ptr is first pointing at Child1 and then it should point at Child2" -- this is not phrased correctly for how pointers work. Pointers point to objects, not classes. So you could say that ptr first points to an object of type Child1, and then it should point to an object of type Child2 (which is necessarily a different object with just what's in the question).
“指针说PTR首先指向Child1，然后它应该指向Child2”--对于指针的工作方式来说，这是不正确的措辞。指针指向对象，而不是类。因此，您可以说，ptr首先指向一个Child1类型的对象，然后它应该指向一个Child2类型的对象(这必然是一个与问题中的内容不同的对象)。
Casts are not a magic way to convert one object type into another. How would the compiler know how to do that? Casts are basically just a way of saying to the compiler "shut up, I know what I'm doing and if you interpret this foo as a bar it'll be fine", but it's on you to then make sure that the cast actually makes sense and if it doesn't, then you have UB on your hands. Casts are rarely the correct solution - sure, cases exist where casts make sense - they are few and far between and you really should be a C++ expert before using them.
强制转换不是将一种对象类型转换为另一种对象类型的神奇方法。编译器如何知道如何做到这一点？强制转换基本上只是一种对编译器说“闭嘴，我知道我在做什么，如果你把这个foo解释为一个bar就好了”的一种方式，但接下来要由你来确保强制转换真正有意义，如果它不有意义，那么你就有了UB。强制转换很少是正确的解决方案-当然，在某些情况下强制转换是有意义的-它们很少，在使用它们之前，您确实应该成为一名C++专家。
Parent ptr = new Child1() will not compile, since ptr is not declared as a pointer. You need to add a * to it, eg:
父ptr=new Child1()将不会编译，因为ptr没有声明为指针。你需要在它后面加上一个*，例如：
Parent *ptr = new Child1();
Now then, (Child2 *)ptr is undefined behavior, because a Child1 object is not a valid Child2 object and vice versa, so you can't just type-cast the pointer. You need to point at a whole separate Child2 object, eg:
现在，(Child2*)PTR是未定义的行为，因为Child1对象不是有效的Child2对象，反之亦然，所以您不能只对指针进行类型转换。你需要指向一个完全独立的Child2对象，例如：
Parent *ptr = new Child1();
...
delete ptr;
ptr = new Child2();
...
delete ptr;
Don't forget to add a virtual destructor to Parent!
别忘了给Parent添加一个virtual析构函数！
Now, you can do the same thing with smart pointers, eg:
现在，你可以用智能指针做同样的事情，例如：
unique_ptr<Parent> ptr = make_unique<Child1>();
...
ptr = make_unique<Child2>();
0
在指向指针的指针上使用指针算术是否定义明确？ 例如 int a=some_value; int* p=&a; int**p2=&p; 现在对 p2 执行算术是否是定义明确的行为？(例如 p2+1、p2
我正在尝试使用一个函数来替代 C 中的 scanf()。该函数是由第三方编写的，并进行了相应的定义: ScanDecimal16uNumber - Scans a decimal 16bit unsi
我正在尝试为 Sundials CVODE 编写 CFFI 包装器图书馆。 SWIG 被 Sundial header 阻塞，因为它们相互关联，并且 SWIG 找不到合适的 header ，所以我手工
这个问题已经有答案了: 已关闭11 年前。 Possible Duplicate: pass by reference not working 我正在阅读一些教程 linklistproblem在互联
我有一个代码片段很难理解。 char *c; // c is uni dimensional table ( single row ) char **p ; // p is a two dimen
我正在将一些代码移植到 Windows 并且被难住了。有一些代码在启动时自动运行以将指针复制到指针，并在退出时再次运行以删除指向指针的指针(如果它不为空)。 我已经创建了一个示例程序来重现该行为 in
将非 const 指针转换为 const 指针是合法的。 那为什么将指向非const的指针转换为指向const的指针是不合法的呢？ 例如，为什么下面的代码是非法的: char *s1 = 0; con
将非 const 指针转换为 const 指针是合法的。 那为什么将指向非const的指针转换为指向const的指针是不合法的呢？ 例如，为什么下面的代码是非法的: char *s1 = 0; con
将指向非常量的指针转换为指向常数的指针是合法的。 那么为什么将指向非const的指针转换为指向const的指针是不合法的呢？ 例如，为什么下面的代码是非法的: char *s1 = 0; const
之间有什么区别 procedure(some_routine), pointer :: ptr ptr => null() 和 procedure(some_routine), pointer ::
只是为了消除一些困惑。我最近遇到了这段代码(使用指针到指针): int encode(unsigned char type, uint64_t input_length, unsigned char*
我已经阅读了我能找到的有关 C/C++ 指针的内容，但其中大部分是介绍性的，虽然它可以帮助您理解它们的使用，但在许多情况下，现有代码会抛出难以破译的示例。 我确实看到了一些例子，他们将一行代码分解成它
我一直在关注的学习数据结构的书使用“单指针”作为函数中的参数，这些函数在链表的不同位置添加新节点，例如在开始，在结束。同样在删除的情况下使用“pointer-to-pointer”。在所有这些情况下，
考虑这段代码: #define MAX 4 ............ ............ int** ptr = (int**)malloc(sizeof(int*)*MAX); *ptr =
如何将指向 void 对象的指针转换为类对象？ 最佳答案 使用 static_cast。请注意，只有当指针确实指向指定类型的对象时，您才必须这样做；也就是说，指向 void 的指针的值取自指向此类对象
我假设一种语言的实现允许您将指针视为整数，包括对它们进行标准算术。如果由于硬件限制这是不现实的，请告诉我。如果编程语言通常没有这么强大的指针运算，但是在实践中是可行的，那么我仍然想知道这种实现BigI
我是一名 nodejs 开发人员，我通常为我的应用程序使用一个结构，该结构包含一个配置包/对象，该对象包含对我常用的库和配置选项的引用。通常，此配置对象也包含我的数据库连接，并且可以通过我的应用程序访
我已经在几个上下文中阅读过“胖指针”这个术语，但我不确定它的确切含义以及它何时在 Rust 中使用。指针似乎是普通指针的两倍，但我不明白为什么。它似乎也与特征对象有关。 最佳答案 术语“胖指针”用于指
这是让我困惑的代码。 static char *s[] = {"black", "white", "pink", "violet"}; char **ptr[] = {s+3, s+2, s+1, s
通用指针允许您创建指向指针的指针: void foo(Object **o) {} int main() { Object * o = new Object(); foo(&o); } s
我是一名优秀的程序员,十分优秀！