How to Assign a Base Class Object to a Derived Class Reference with an Explicit Typecast

Is it possible to assign a base class object to a derived class reference with an explicit typecast?

No. A reference to a derived class must actually refer to an instance of the derived class (or null). Otherwise how would you expect it to behave?

For example:

object o = new object();
string s = (string) o;
int i = s.Length; // What can this sensibly do?

If you want to be able to convert an instance of the base type to the derived type, I suggest you write a method to create an appropriate derived type instance. Or look at your inheritance tree again and try to redesign so that you don't need to do this in the first place.

Why explicit conversion required to assign base class to derived class? But not required to do the reverse

When you use explicit conversion, in your case, you are telling the compiler that you know what is going on. If you were to compile your code, removing d = a;, and you tried to access a public member on d, and exception would be thrown. That is because, in this instance, the animal is not a dog. You explicitly created an animal and assigned it to a.

Explicit conversion allows you to do thing when you know the conversion will work.

public class MyClass
{
    public animal MyAnimal { get; private set; }

    public MyClass ()
    {
        MyAnimal = new dog ();
    }

    public void SetAge (int Age)
    {
        ((dog)MyAnimal).age = Age;
    }
}

In this case, we know that MyAnimal is actually a dog, so we can do an explicit cast to it. All of this works because of inheritance. Because inheritance does not work both ways, the complier will not allow an implicit up cast--you must do it explicitly.

We know that when a class inherits from its base class, it takes with it the public properties and methods. You cannot say that your reference to an animal will always contain the properties and methods of a dog.

Is it possible to assign a base class object to a derived class reference with an explicit typecast?

No. A reference to a derived class must actually refer to an instance of the derived class (or null). Otherwise how would you expect it to behave?

For example:

object o = new object();
string s = (string) o;
int i = s.Length; // What can this sensibly do?

If you want to be able to convert an instance of the base type to the derived type, I suggest you write a method to create an appropriate derived type instance. Or look at your inheritance tree again and try to redesign so that you don't need to do this in the first place.

Convert base class to derived class

No, there's no built-in way to convert a class like you say. The simplest way to do this would be to do what you suggested: create a DerivedClass(BaseClass) constructor. Other options would basically come out to automate the copying of properties from the base to the derived instance, e.g. using reflection.

The code you posted using as will compile, as I'm sure you've seen, but will throw a null reference exception when you run it, because myBaseObject as DerivedClass will evaluate to null, since it's not an instance of DerivedClass.

Is it possible for a derived class to hold a reference to an existing base class in C#?

Here's how you would typically do this:

public class A
{
    public A(string name, int value) 
    {
      this.Name = name;
      this.Value = value;
    }
    public string Name { get; set; }
    public int Value { get; set; }
}

public class B : A
{
    public B(A a) : this(a.Name, a.Value, 0)
    {
    }
    public B(string name, int value, int ranking) : base(name, value)
    {
      this.Ranking = ranking;
    }
    public int Ranking { get; set; }
}

Study this carefully and make sure you understand how it works. If you have a question about how it works, post a new, precise, clear question.

Now, this does not have the property that you want, namely, that updates to A also update B. The way to do that odd thing is to abandon the is-a-kind-of relationship between B and A:

public class B
{
    private A a;
    public B(A a)
    {
      this.a = a;
    }
    public int Ranking { get; set; }
    public int Value 
    { 
      get { return this.a.Value; }
      set { this.a.Value = value; }
    }
    public string Name 
    { 
      get { return this.a.Name; } 
      set { this.a.Name = value; }
    }  
}

Now, if you want to have both B deferring to A, and also B being an instance of A, then you have a harder problem; the properties of A have to be virtual, and overridden in B. I leave that as an exercise.

But really it sounds like you are trying to do something very strange here. Can you describe the problem you're actually trying to solve? Odds are pretty good you're doing it wrong.

Cast a C# Class to his child class

A parent is not a child, hence this cast is impossible. To understand this, biological terms are often the best: There is a class Animal and two classes Fox and Deer whic hinherit Animal. You cannot cast an Animal to Fox, because it might be a Deer.

If you want to do this, I recommend that you add a constructor to child which copies field1 and field2 from a parent:

public class ChildClass : ParentClass
{
    public ChildClass(ParentClass parent)
    {
       field1 = parent.field1;
       field2 = parent.field2;
    }

    public String field3;
}

You can call it like that:

var c2 = new ChildClass(c1);     
c2.field3 = "ccc";

How to cast a base class to a derived class

p is an instance of Parent, so you cannot tell the runtime to interpret it as one.

The compiler does not catch it because code like this

 Parent p = new Child();
 Child c = (Child)p;

and compilers do not do the static code analysis needed to catch it. Reasons for not checking it are:

• It is time consuming

• It can only catch some of the instances of the error.

Why doesn't this code cast a base class into a derived class in c++?

Whenever you push an object of b into vector vec of Base Objects, you create another object from temp which is purely of type base. You might be thinking (and you are not right!) that element which is being stored in vector will be of type Base but it will be holding an object of type bbut it's not how you achieve Dynamic Polymorphism in C++.

The statements:

std::vector<Base> vec; // 1
b temp;                // 2
vec.push_back(temp);   // 3

The third line will create a different object to type Base by calling assignment operator of base class Base operator=(const Base& ).

Also,b* temp = (b*)&vec[i]; is an undefined behavior because you are explicitly trying to cast a pointer to object of base to it's derived class type b but it doesn't hold object of type b and hence, you may get unexpected behavior.

NOTE:

Use dynamic_cast for casting between base and derived class as it will make sure that the conversion is valid. Otherwise, it will return nullptr. However, you need to make your base class polymorphic by having at least 1 virtual function.

If the cast is successful, dynamic_cast returns a value of type new-type. If the cast fails and new-type is a pointer type, it returns a null pointer of that type. If the cast fails and new-type is a reference type, it throws an exception that matches a handler of type std::bad_cast.

SOLUTION:

Use vector of pointers to base class to achieve run-time polymorphism.

std::vector<base *> vec;
for (int i = 0; i < 5; i++) {
    b *temp = new b();
    vec.push_back(temp);
}

for (int i = 0; i < 5; i++) {
    b* temp = dynamic_cast<b *>(vec[i]); // For dynamic cast, you need to add virtual functions to your base class
    if (temp != nullptr)
        std::cout << temp->d << std::endl;
}

EDIT:

Object Slicing is also a solution for your problem. Object Slicing is the right keyword for this type of problems. Here is the definition of the Object Slicing

Object slicing happens when a derived class object is assigned to a base class object, additional attributes of a derived class object are sliced off to form the base class object.

I am quoting one of the answer in the link below. See this answer and answer for the best explanation and possible solution with some code snippet. See this article, it has explained the problem when pushing object of Derived class in a vector of base class.

"Slicing" is where you assign an object of a derived class to an instance of a base class, thereby losing part of the information - some of it is "sliced" away.

For example,

class A {
   int foo;
};

class B : public A {
   int bar;
};

So an object of type B has two data members, foo and bar.

Then if you were to write this:

B b;
A a = b;

Then the information in b about member bar is lost in a.

Unable to cast base class to derived class

In Case two you have an instance of dog and animal

Animal a = new Animal();
Dog d = new Dog();

Then you have reference copy of dog to animal

a = d;

So the a is points to d and d is a dog instance and instance properties like noOfTail is still exist but is hidden and not available in object a.
and then you have this line :

d = (Dog)a;

In last line you have reference copy of d to a ,so d is point to where a is point to so everything is okay.

but in case one you want copy one Instance of child class Dog to an instance of Animal so the properties of child class will be lost. you need to confirm that with Compiler and say to him you know instance properties like noOfTail will not be available any more
your code most be like this :

 Animal a = new Animal();
 Dog d = new Dog();
 d = (a as Dog); 

---

Related Topics