C++ identify data structure from adress - c++

Question

I would like to know if there is a way in C++ to know in what data structure an address is. For example, I have a base class (A) that has two inherited class (B and C). In a fourth class (D), I have two vectors of the STL, one containing pointers of B, the second containing pointers of C.
In D, I am implementing a method that is withdrawing an object A. In that method, I am using another implemented function of D that is searching in the vectors if the object A is there and return a pointer to this object.
Is there a way after that to manipulate the appropriate vector of where the object A to directly delete it from the vector (knowing in what vector it is and its position in the vector) ?
A* D::findA(string word)
{
for (unsigned int i = 0; i < vectorOfB_.size(); i++) {
if ( vectorOfB_[i]->getWord() == word)
return vectorOfB_[i];
}
for (unsigned int i = 0; i < vectorOfC_.size(); i++) {
if (vectorOfC_[i]->getWord() == word)
return vectorOfC_[i];
}
bool D::withdrawA(string word)
{
A* obj = findA(word);
if (obj != nullptr) {
}
return false;
}
At this point, I know that the method found the object A, I know its address, but I don't know in what vector it is. I would like to use the erased() method of the STL vector class to withdraw it from the vector, but without doing loops again to go check in the vectors.

Answer 1

I guess you could use dynamic_cast to determine if the pointer of A is of type B or 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;
}

Answer 2

Since you are querying a member of the class (word) in order to identify the object, I don't think you need some maginc machanism to achive what you want.
You can use the STL algorithms for that, for instance having the classes:
#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;
You can write a function:
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
}
Now you an use that function with both vectors.
A more specific example.
You can use STL algorithms in order to erase from your vectors too:
Suppose you have found some A*
A* a_ptr = findA(word);
Then you can use STL erase, remove_if idiom:
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());

Answer 3

In C++, there is no way to directly know the data structure by an address.