A hack to circumvent access - how bad?
Hello,
Please consider the code below. The 'BS/CS/DS' class hierarchy lives in
a third-party library that I can't change. It's broken (a little) in
the sense that I need to call a protected member function of 'BS' from
outside of the hierarchy. The 'A/AA/AAA' is my own hierarchy.
To gain access to 'BS::foo' from 'A::bar', I perform a dirty hack (see
the static_cast). The only hope is that since 'HackBS' contains no data
members of its own, it won't disturb the hierarchy (memory layout, etc).
Oh, there are, of course other members in 'BS' that do not represent an
access problem...
Another thing: we aren't supposed to use virtual or multiple inheritance
for this project.
So, give it to me straight: is this hack a disaster waiting to happen?
So far it "worked" (produced the desired results), although of course
the code has UB, AFAIUI.
--------------------------------------------
#include <iostream>
#include <ostream>
class BS
{
char bs;
public:
BS(char b) : bs(b) {}
virtual ~BS() {}
protected:
virtual void foo()
{ std::cout << "BS::foo(), bs = " << bs << "\n"; }
};
class CS : public BS
{
int cs;
public:
CS(int c) : BS(c % 10 + '0'), cs(c) {}
void foo()
{ BS::foo(); std::cout << " CS :: foo(), cs = " << cs << '\n'; }
};
class DS : public CS
{
double ds;
public:
DS(double d) : CS(int(d*100)), ds(d) {}
protected:
void foo()
{ CS::foo(); std::cout << " DS :: foo(), ds = " << ds << "\n"; }
};
class HackBS : public BS
{
friend class A;
public:
HackBS() : BS(0) {}
};
class A
{
BS* pBS;
public:
void setBS(BS* p) { pBS = p; }
void bar() { static_cast<HackBS*>(pBS)->foo(); }
};
class AA : public A
{
};
class AAA : public AA
{
};
int main()
{
A a;
a.setBS(new BS('z'));
a.bar();
AA aa;
aa.setBS(new CS(42));
aa.bar();
AAA aaa;
aaa.setBS(new DS(3.14159));
aaa.bar();
}
--------------------------------------------
Thanks!
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask