Re: access modifier in c++
* toton.basak@gmail.com:
In C++ any i can simulate some restricted access modifiers based on
association & inheritance?
eg,
class BombMaker{
private:
void makeAtomBomb(){
std::cout<<"making atom bomb\n";
}
int getSecretFormula()const{return 51;}
protected:
void makeRDX(){
std::cout<<"making RDX\n";
}
int getRDXFormula()const{return 101;}
std::vector<BombMaker*> helpers;
public:
void makeFireCracker(){
std::cout<<"making firecrackers\n";
}
void makeAtomBombFor(BombMaker& m){
m.makeAtomBomb();
}
void stealFormula(BombMaker& o){
int formula = o.getSecretFormula();
}
};
here,
BombMaker* bad = new BombMaker();
BombMaker* notSoBad = new BombMaker();
bad->makeAtomBombFor(*notSoBad);/// i want this to work as now it
works. so another bomb maker can give the bad one to make a bomb for
him.
bad->stealFormula(*notSoBad);/// but bad one even can steal the
formula for the bomb through association with notSoBad. That should
not be allowed as the formula is only for personal use and is
dangerous for world. Can private be made exclusive so that association
is not allowed for private?
ie, essentially getSecretFormula() can only be used by the object
itself.
Simply don't expose that functionality via any protected or public member function.
secondly,
i have a derived class,
class DestructiveBuddy : public BombMaker{
public:
void getFormula(BombMaker& o){//1
int formula = o.getRDXFormula();
}
void getFormulaFrom(DestructiveBuddy o){
int formula = o.getRDXFormula();
}
void acquireFormula(){
int formula = getRDXFormula();
}
void getFromHelpers(){//2
for(std::size_t i = 0; i< helpers.size();++i){
helpers[i]->getRDXFormula();
}
}
};
now is there any way to have a protected modifier which allows an
DestructiveBuddy to getFromula from a BombMaker also (as he himself is
a BombMaker) as in (1) along with other DestructiveBuddy's.
No, not for direct access. However, DestructiveBuddy can access the protected
getRDXFormula of a BombMaker via a member function pointer. Member function
pointers are about on the level of goto: don't use unless you absolutely need
to, because there's very little protection.
class DestructiveBuddy : public BombMaker{
private:
static int rdxFormulaFrom( BombMaker& o )
{
int (BombMaker::*getter)() const = &DestructiveBuddy::getRDXFormula;
return (o.*getter)();
}
public:
void getFormula(BombMaker& o){//1
int formula = rdxFormulaFrom( o );
}
void getFormulaFrom(DestructiveBuddy o){
int formula = o.getRDXFormula();
}
void acquireFormula(){
int formula = getRDXFormula();
}
void getFromHelpers(){//2
for(std::size_t i = 0; i< helpers.size();++i){
rdxFormulaFrom( *helpers[i] );
}
}
};
Note that this is only technical information about what you're asking.
If you do use this for gaining access, you're doing yourself (or someone) a
great disservice -- instead design the classes with proper access! In
considering this advice, take into account that you had to ask and I knew an
answer. Therefore, chances are that this advice about avoiding member function
pointers (for this purpose, and generally direct use of them) is well-founded.
Cheers, & hth.,
- Alf
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?