CODEWITHSUNDEEP
c++shared-ptrsmart-pointers
pZCZ
pZCZ

Reputation: 183

How to get access to the derived std::shared_ptr?

Suppose I have code like that one, and I want to get access to the myClassB members. How can I do that? I need to use the functionality of functionA. I can't change it because it is from the 3rd party library. And I need to use functionA to create it, and get values created by it. In this case "Test_1" string

class myClassA {
public:
    myClassA(){}
    ~myClassA(){}
};

class myClassB : public myClassA
{
public:
  myClassB(){}
  void setString1(std::string newString)
  std::string getS1()     
private:
  std::string privateMember;
};

std::shared_ptr<myClassA> functionA()
{
  std::shared_ptr<myClassB> temporary(new myClassB());
  temporary->setString1("TEST_1");
  return std::move(temporary);
}

int main()
{
  std::shared_ptr<myClassA> myPtr; // = functionA(); ??
}

Upvotes: 0

Views: 483

Answers (2)

James Poag
James Poag

Reputation: 2380

Agree with dynamic_cast but without a virtual function table in ClassA, something like this would have to do:

Test This Code

#include <string>
#include <memory>
#include <iostream>
#include <set>

class myClassA {
public:
    myClassA(){}
    ~myClassA(){}
};

class myClassB;
class ClassB_Registry{
    private:
    ClassB_Registry(){
    }
    ~ClassB_Registry(){
    }
    public:
    static ClassB_Registry* Get(){ static ClassB_Registry obj; return &obj; }
    static void Register(myClassB* ptr){
        Get()->mPointers.insert(ptr);
    }
    static void UnRegister(myClassB* ptr){
        Get()->mPointers.erase(ptr);
    }
    static myClassB* Cast(myClassA* ptr){
        if(Get()->mPointers.count((myClassB*)ptr) > 0) return (myClassB*)ptr;
        return nullptr;
    }

    private:
    std::set<myClassB*> mPointers;
};



class myClassB : public myClassA
{
public:
myClassB(){ ClassB_Registry::Register(this); }
~myClassB(){ ClassB_Registry::UnRegister(this); }
void setString1(std::string newString){privateMember = newString;}
std::string getS1() { return privateMember; }
private:
std::string privateMember;
};

std::shared_ptr<myClassA> functionA()
{
std::shared_ptr<myClassB> temporary(new myClassB());
temporary->setString1("TEST_1");
return std::move(temporary);
}

int main()
{
std::shared_ptr<myClassA> myPtr = functionA(); //??
std::shared_ptr<myClassA> myPtr_a(new myClassA()); //??
myClassB* pDerrived = ClassB_Registry::Cast(myPtr.get()); // bridge the RTTI gap
if(pDerrived) 
    std::cout << pDerrived->getS1();

pDerrived = ClassB_Registry::Cast(myPtr_a.get()); // works on A pointers to return null
if(pDerrived) 
    std::cout << pDerrived->getS1() << "    \n";
else
    std::cout << "Not A Pointer of Type B" << "    \n";
}

It's not pretty, but if myClassB had a virtual table as mentioned previously, and all future derived classes used myClassB as the base, then you could bridge the gap for RTTI.

Upvotes: 1

Xirema
Xirema

Reputation: 20396

Theoretically, you could use a dynamic_cast (or in this case specifically, std::dynamic_pointer_cast to get the derived pointer type. Like so:

std::shared_ptr<MyClassA> a_ptr = functionA();
std::shared_ptr<MyClassB> b_ptr = std::dynamic_pointer_cast<MyClassB>(a_ptr);
if(b_ptr) {//Check to verify the cast was successful
    b_ptr->setString("Test1");
}

There is, however, a major caveat to this. In order for dynamic_cast (and therefore std::dynamic_pointer_cast) to work, your object hierarchy must have a virtual table defined. That means at least one of the methods defined by MyClassA must be declared virtual. The simplest solution is to declare the destructor virtual, since that's good practice whenever you're defining polymorphic objects (since you need it to ensure that any derived classes clean up their resources correctly).

class MyClassA {
public:
    MyClassA() = default;
    virtual ~MyClassA() = default;
};

Upvotes: 3

Related Questions