C++；从地址识别数据结构 我想知道C++中有没有一种方法知道地址是什么数据结构。例如，我有一个基类（a），它有两个继承类（B和C）。在第四个类（D）中，我有两个STL向量，一个包含B的指针，第二个包含C的指针

在D中，我实现了一个方法，该方法提取对象a。在该方法中，我使用了D的另一个实现函数，该函数在向量中搜索对象a是否存在，并返回指向该对象的指针

之后有没有办法操纵对象a所在位置的适当向量，直接将其从向量中删除（知道它在哪个向量中以及它在向量中的位置）

A*D:：findA（字符串字）
{
for（unsigned int i=0；igetWord（）==word）
返回向量b_i；
}
for（unsigned int i=0；igetWord（）==word）
返回向量c_i；
}
bool D：：提取（字符串字）
{
A*obj=findA（单词）；
if（obj！=nullptr）{
}
返回false；
}

---

此时，我知道该方法找到了对象A，我知道它的地址，但我不知道它在哪个向量中STL vector类的方法将其从向量中提取，但无需再次执行循环来检查向量。

我想您可以使用动态转换来确定A的指针是B型还是C型

bool D::withdrawA(string word)
{
    A* obj = findA(word);
    if (obj != nullptr) {
        if(dynamic_cast<B*>(obj) != nullptr) {
           // do something here for the B vector
        }
        else if(dynamic_cast<C*>(obj) != nullptr)
        {
           // do something here for the C vector
        }
    }
    return false;
}

bool D:：提取（字符串字）
{
A*obj=findA（单词）；
if（obj！=nullptr）{
if（动态（obj）！=nullptr）{
//对B向量做点什么
}
否则如果（动态_转换（obj）！=nullptr）
{
//在这里对C向量做点什么
}
}
返回false；
}

由于您要查询类成员（

word

）以识别对象，因此我认为您不需要一些神奇的机制来实现您想要的

您可以为此使用STL算法，例如，具有以下类：

#include <memory>
#include <algorithm>
#include <vector>
#include <string>


using namespace std;


class A {
public:
    A(string word = "") :m_word(word){}
    virtual inline string getWord() { return m_word; }
protected:
    string m_word;
};

class B : public A { 
public: 
    B(string word = "") : A(word) {} 
};  

class C : public A { 
public:
    C(string word = "") : A(word) {} 
};


typedef shared_ptr<A> a_ptr;      
typedef vector<a_ptr> a_vector;

然后，您可以使用STL擦除，如果习惯用法为：

vectorOfB_.erase(remove_if(vectorOfB_.begin(), vectorOfB_.end(), 
    [a_ptr](A* elem){
        return elem->getWord() == a_ptr->getWord();
    }
), vectorOfB_.end());

vectorOfC_.erase(remove_if(vectorOfC_.begin(), vectorOfC_.end(), 
    [a_ptr](A* elem){
        return elem->getWord() == a_ptr->getWord();
    }
), vectorOfC_.end());

---

在C++中，没有办法直接通过地址来知道数据结构。

请提供一个例子，也许是你试图做的一些用例。如果基类不是一个共同的分母，为什么你有继承层次？你的意思是A的向量？我正在工作的运动需要有两个不同的向量。s是继承类的一部分，因此它使编写代码的时间更长，并且在这之后教我们多态性在哪些方面是有用的。很抱歉，但是这个练习似乎被误导了。您要么关心对象的具体类型（在这种情况下，您通过具体类型

B

或

C

）或者你没有，然后你通过一个

A

指针或引用进行操作。我如何通过一个指针进行操作？这将使我不得不再次使用向量中的一个循环。我想知道是否有一种方法可以直接调用被擦除的（）方法。您不能更改findA函数，使其接受通过引用传递的第二个参数（int类型），该参数将建议位置（i）？如果可以，则不需要第二个循环。甚至无法更改函数的原型。谢谢您的回答，但在我的情况下，我无法更改函数或类的原型是非常具体的。在这种情况下，似乎没有捷径可以实现我所需的。我的示例只是一个如何实现的指南你想要什么。我会举一个更具体的例子。@BlueWizard，再次检查答案。谢谢你的回答，但是在这个特定的情况下，我们不能更改程序中的任何类或函数，这是不尊重的。它肯定会起作用，在任何你可以自由编码的情况下，这都是一个很好的方法。我很感激。

a_ptr find_A(a_vector v, string word, bool erase = false){

    // Find the element.
    auto it = find_if(v.cbegin(), v.cend(),
        [word](const a_ptr &elem) {
            return elem->getWord() == word;
        }
    );

    // If you want to erase and it was found.
    // The code below can be implemented in a more elegant way, but
    // for that your classes will require you overload < operator and == operator.
    if (erase && it != v.end()) {
        v.erase(remove_if(v.begin(), v.end(), 
            [word](a_ptr elem){
                return elem->getWord() == word;
            }
        ), v.end());
    }

    return *it
}

A* a_ptr =  findA(word);

vectorOfB_.erase(remove_if(vectorOfB_.begin(), vectorOfB_.end(), 
    [a_ptr](A* elem){
        return elem->getWord() == a_ptr->getWord();
    }
), vectorOfB_.end());

vectorOfC_.erase(remove_if(vectorOfC_.begin(), vectorOfC_.end(), 
    [a_ptr](A* elem){
        return elem->getWord() == a_ptr->getWord();
    }
), vectorOfC_.end());