..be compatible with another class?
By the way, 'access variable' is the variable used to access the a class. Heres what I mean:
[code]
#include <iostream>
class Database
{
public:
int x;
}Data;
class Storage
{
public:
int y;
}Stor;
int main(int argc, char *argv[])
{
Storage *access;
access= (Database&)Stor; // Is this legal?
// If not, is there another way of pulling this stunt?
access.x= 9;
cin.get();
return 0;
}
ignoring the problems with your syntax, yeah its legal... although in most cases it wont give you the desired result. You might be able to use a void pointer and just cast the pointer when you want to use it.
void *ptr = (void *)&something;
((something *)ptr)->method1();
kinda ugly, but it will probably work...
However, inheritance and polymorphism might be better for what you want
Like *ClownPimp* sez, you should probably use polymorphism by Deriving the two classes from the same Base class.
Because of this a pointer to the base class can then refer to either object and call methods of that same name in either that are in the base class or overriden in either class.
Here is an example or what polymophism can do for you:
Code:#include <iostream>
using namespace std;
//
// Really poor class definitions without .h files and so on
//
//--------------------
// Base
//--------------------
class Base
{
public:
Base(){}
// overridables
virtual ~Base(){}
virtual int GetX()
{
cout << "Base GetX()" << endl;
return x;
}
virtual void SetX(int newx) { x = newx;}
protected: // must be at least protected
int x;
}B;
//-------------------------
// DerivedA
//-------------------------
class DerivedA : public Base
{
public:
DerivedA(){}
~DerivedA(){}
int GetX()
{
cout << "DerivedA GetX()" << endl;
return x + 1;
}
}DA;
// A function that calls cout << b_ptr->GetX() << endl;
void PrintX(Base * b_ptr);
//-----------------------
// DerivedB
//-----------------------
class DerivedB : public Base
{
public:
DerivedB(){}
~DerivedB(){}
int GetX()
{
cout << "DerivedB: GetX()" << endl;
return x - 1;
}
}DB;
//------------------
// Main
//------------------
int main()
{
Base * b_ptr;
B.SetX(10); // Should come back as 10
DB.SetX(10); // Should come back as 11
DA.SetX(10); // Should come back as 9
//Point to B
b_ptr = (Base *)&B;
PrintX(b_ptr); // 10
// Point to DA
b_ptr = (DerivedA *)&DA;
PrintX(b_ptr); // 11
// Point to DB
b_ptr = (DerivedB *)&DB;
PrintX(b_ptr); // 9
return 0;
}
// calls GetX() on pBase, but because each Derived class
// overrides it, you get different results based on each
// class, but can switch back for between each when needed
void PrintX(Base * pBase)
{
cout << pBase->GetX() << endl;
}