Pure virtual methods in C#?

Question

I've been told to make my class abstract:

public abstract class Airplane_Abstract

And to make a method called move virtual

 public virtual void Move()
        {
            //use the property to ensure that there is a valid position object
            double radians = PlanePosition.Direction * (Math.PI / 180.0);

            // change the x location by the x vector of the speed
            PlanePosition.X_Coordinate += (int)(PlanePosition.Speed * Math.Cos(radians));

            // change the y location by the y vector of the speed
            PlanePosition.Y_Coordinate += (int)(PlanePosition.Speed * Math.Sin(radians));
        }

And that 4 other methods should be "pure virtual methods." What is that exactly?

They all look like this right now:

public virtual void TurnRight()
{
    // turn right relative to the airplane
    if (PlanePosition.Direction >= 0 && PlanePosition.Direction < Position.MAX_COMPASS_DIRECTION)
        PlanePosition.Direction += 1;
    else
        PlanePosition.Direction = Position.MIN_COMPASS_DIRECTION;  //due north
}

Answer 1

My guess is that whoever told you to write a "pure virtual" method was a C++ programmer rather than a C# programmer... but the equivalent is an abstract method:

public abstract void TurnRight();

That forces concrete subclasses to override TurnRight with a real implementation.

Answer 2

They probably mean that the methods should be marked abstract.

 public abstract void TurnRight();

You will then need to implement them in the subclasses, as opposed to an empty virtual method, where the subclass would not have to override it.

Answer 3

"Pure virtual" is C++ terminology. The C# equivalent is an abstract method.

Answer 4

http://en.wikipedia.org/wiki/Virtual_function

"In object-oriented programming, a virtual function or virtual method is a function or method whose behaviour can be overridden within an inheriting class by a function with the same signature."

Google is always your friend.

Answer 5

You then don't have an implementation in the Airplane_Abstract Class but are forcing consumers "inheritors" of the Class to implement them.

The Airplane_Abstract Class is unusable until you inherit and implement the abstract functions.

Answer 6

A pure virtual function is terminology of C++ but in C# if a function which is implemented in Derived class and that derived class is not an Abstract class.

abstract class PureVirtual
{
    public abstract void PureVirtualMethod();
}

class Derivered : PureVirtual
{
    public override void PureVirtualMethod()
    {
        Console.WriteLine("I'm pure virtual function");
    }
}

Answer 7

Or even you can go interface, thought some little limitation is required:

public interface IControllable
{
    void Move(int step);
    void Backward(int step);
}

public interface ITurnable
{
   void TurnLeft(float angle);
   void TurnRight(float angle);
}

public class Airplane : IControllable, ITurnable
{
   void Move(int step)
   {
       // TODO: Implement code here...
   }
   void Backward(int step)
   {
       // TODO: Implement code here...
   }
   void TurnLeft(float angle)
   {
       // TODO: Implement code here...
   }
   void TurnRight(float angle)
   {
       // TODO: Implement code here...
   }
}

However, you will have to implement all the function declaration of both IControllable and ITurnable have assigned, otherwise an compiler error will occur. If you want optional virutal implementation, you would have to go abstract class for virtual method with interface for pure virtual method.

In fact, there is a difference between interface function and abstract function, that interface only declares function, all interface function have to go all public so there's no fancy class property such as private or protected so it's very fast, while abstract function are actual class method without implementation and forces the implementation in the derived class, so you can put private, protected and access member variables with abstract functions, and most of the time it's slower because the class inheritance relations are analyzed in run time. (aka vtable)