switching between base and deriven classes

This code will not even compile. For example ';' terminators after operators are missing. If you need better answers, please check up your code using a real compiler.

Now, what you do 1) is irrelevant to the differences between C#, C++ (which you're trying to use here) or C++/CLI; 2) you code is not object-oriented at all; consider you do not have classes at all, the quality of your code will be exactly the same.

When you use object-oriented approach you use type case and operator "is" or "as" very rarely. In C++, there is no such operators, but the dynamic typecast is available in the form of dynamic_cast<>, see http://en.wikipedia.org/wiki/Dynamic_cast[^].

Now, that said, even in C# you did not know how to use OOP. The idea of using derived class is providing a base class which represent the common interface for the hierarchy and using virtual methods and overriding to provide late binding, see http://en.wikipedia.org/wiki/Late_binding[^]. You should know the difference between compile-time and run-time types. The idea is using some base type as a compile-time type for a variable, but instantiate one of derived types.

The construct working as a .NET interface in C++ (not C++/CLI) is represented by the class having no data and only pure-virtual functions, see http://en.wikipedia.org/wiki/Pure_virtual_method#C.2B.2B[^] and the section "Abstract classes and pure virtual functions".

There is a lot more to it. I suggest you take a good manuals for OOP in C#, C++/CLI, .NET and C++ (pick just one for starters) and learn how OOP really works. You will really need it.

You also have some change to get a practical advice in your particular case, but in this case you will need to explain your ultimate goal. In your follow-up question, please do not use the much of the notion of the class (you don't really know what is it — just yet) but focus more on the application aspects.

Good luck,

—SA

Generally speaking, in standard, unmanaged C++ there's no way to tell them apart, since they're just pointers. That's one of the advantages of using object oriented programming, polymorphism, but its up to the designer to keep track of the type of objects that his derived classes can become.

John's solution is nice, but there's other ways to keep track, just have to be a bit inventive.

class base
{
 protected:
 int m_type;
 
 public:
 base(){m_type=0;}
};
class derived1 : public base
{
 public:
 derived1(){m_type=1;}
}
class derived2 : public base
{
 public:
 derived2(){m_type=2};
}

You can even add an enumerated list of supported types in the base.

class base
{
 enum TYPE{BASE =0, DER1, DER2, DER_MAX=DER2};

 protected:
 TYPE m_type;

 public:
 base(){m_type=BASE;} //And just define the others accordingly
};

...and I agree with SA, the whole point of using derived classes is that they share the same common methods.

What you're describing sounds like Variants, i. e. a class that serves as a wrapper for variables of varying type. You can implement these without classes, using union, or google for existing implementations and use those. I believe Managed C++ even has such a class, but I'm not working with that, so I may be wrong.

Solution with union:

struct SVariant {
   enum { VAR_DOUBLE, VAR_INT } vartype;
   union {
      double x;
      int i;
   } value;
};
void setVariant(SVariant* v, double value) {
   v.value.x = value;
   v.type = VAR_DOUBLE;
}
void test(SVariant* v) {
   if (v.type == VAR_DOUBLE) {
       do_double(v.value.x);
   else if (v.type == VAR_INT) {
       do_int(v.value.i);
   }
}

Anyway, in most cases Variants are a bad idea: they place the onus of distinguishing the actual types and deciding what to do with the values on the caller. It is exactly the opposite of what OO-design is about, and so I feel it's wrong to even try and create a class framework for such a concept.

What you should do is create a class for each type of variable, and then put the functions that operate on the values into these classes! You could implement it like this:

// file CBase.h
class CBase {
public:
   virtual ~CBase(); // always define a virtual destructor on a base class!
   virtual void do_work() = 0; // '=0' makes this a 'pure' virtual function
};

// file CDerived1.h
class CDerived1 : public CBase {
private:
   double x_;
public:
   CDerived1(double x);
   ~CDerived1(); // always define the destructor on a derived class!
   void do_work(); // pure virtual functions must be overridden
};

// file CDerived2.h
class CDerived2 : public CBase {
private:
   int i_;
public:
   CDerived2(int i);
   ~CDerived2();
   void do_work();
};

// file CDerived1.cpp
CDerived1::CDerived1(double x) : x_(x) {
}
void CDerived1::do_work() {
   do_double(x_);
}

// file CDerived2.cpp
CDerived2::CDerived2(int i) : i_(i) {
}
void CDerived2.do_work() {
   do_int(i_);
}

// file test.cpp
void test(CBase* b) {
   b->do_work();
}

void main_test() {
   CDerived1 d1(3.14);
   CDerived2(42);
   test(d1); // calls do_double(3.14)
   test(d2); // calls do_int(42)
}

In this solution, the caller test() just calls do_work(), and that's it. it doesn't need to know what derived classes exist, and what to do with each value, the implementation of each derived class does it for you. The caller doesn't even need to know there *are* any derived classes, although the '=0' in this example is a dead giveaway.