i need a good example of virtual functions

Code:

---

ive tried to understand tutiorals about virtual but i still dont understand

so this is just example

class myclass
{
virtual void func1();
public:
};

void myclass::func1()
{
do what ever;
}

now what can be done with this being virtual within the class

---

Code:

---

class MyName
{
private:
        char UserName[NAME_SIZE];

public:
        void SetUserName ( char *NewUserName );

};
void  MyName::SetUserName ( char *NewUserName )
{
        strcpy( UserName, NewUserName );
}


int main()
{
        MyName MyClassName;
        char Name[30];

        cout<< "What is your name?";
        cin >> Name;

        MyClassName.SetUserName( Name );
       
}

---

that sets

that make sense?

you didnt put it as virtual

hmmm, sorry, I didn't notice that ...

I'm afraid I don't know anything about that ... try this though:

Click Here

You need to make a class and derive it from myclass. Then, you need to implement func1 again in the derived class (usually doing something different than myclass's version). Then, you can use myclass polymorphically.

One way to use it is to have a separate function that takes a myclass reference and calls its func1() method. Then you can pass an instance of myclass or the derived class and the correct version of func1 will be called:

Code:

---

#include <iostream>
 
class myclass
{
public:
  virtual void func1();
};
 
void myclass::func1()
{
  std::cout << "myclass::func1" << std::endl;
}
 
class derivedclass : public myclass
{
public:
  virtual void func1();
};
 
void derivedclass::func1()
{
  std::cout << "derivedclass::func1" << std::endl;
}
 
void UseIt(myclass& myc)
{
  myc.func1();
}
 
int main()
{
  myclass a;
  derivedclass b;
  UseIt(a);
  UseIt(b);
}

---

Contrary to what some people may believe, you don't go from writing a "hello world" program to understanding virtual functions a few days later. Virtual functions enable you to enact what's called "polymorphism". That involves understanding what pointers are and how they work, what iheritance is and how it works, and finally how virtual functions play a role. To get "polymorphic behavior", you need several ingredients:

1) A common base class
2) A pointer to the base class
3) A virtual function in the base class
4) Derived classes that override the virtual function in the base class

Code:

---

#include <iostream>
using namespace std;

class Animal
{
public:
        virtual void identify()
        {
                cout<<"I'm an Animal."<<endl;
        }
};

class Dog : public Animal
{
        void identify()
        {
                cout<<"I'm a Dog."<<endl;
        }
};

class Cat : public Animal
{
        void identify()
        {
                cout<<"I'm a Cat"<<endl;
        }
};


int main()
{
        Animal myAnimal;
        Dog myDog;
        Cat myCat;

        Animal* ptr = &myAnimal;
        ptr->identify();

        ptr = &myDog;
        ptr->identify();

        ptr = &myCat;
        ptr->identify();

       
        return 0;
}

---

"Polymorphic behavior" means that you get different results from the same code. The program does the exact same thing three times:

ptr->identify();

but there are three different results. It's as if there is an internal switch statement inside ptr, and ptr first checks to see what type of object is stored inside it before deciding what version of identify() to call.

thanks alot guys , these simple examples are great
any reason why dog and cat dont have public sections?

and


Animal* ptr = &myAnimal; // would this mean the same thing as
Animal *animal= new Animal; //this

Quote:

---

any reason why dog and cat dont have public sections?

---

No. That was just an oversight on my part.

Code:

---

Animal* ptr = &myAnimal; // would this mean the same thing as
Animal *animal= new Animal; //this

---

No they are not the same. Stick with the first unless you understand and have a reason to use the second. The second line involves what's called "dynamically" creating an object.

Just for fun so you can really appreciate the effects of virtual, recompile 7studs program, but remove virtual keyword from the base class leaving everything else the same and observe the output.

whats this

Code:

---

void UseIt(myclass& myc)
{
  myc.func1();
}

---

is this a special meaning when working with virtual
i understand you making te object but you didnt do void Useit(); in the class

and why did

UseIt(a);
UseIt(b);

call the func1(); seeing as its not the constructor

UseIt is a function that is completely separate from the classes. Think of it as something like the getline function for strings if you are familiar with that. What it does is use an instance of myclass (or one of myclass's derived classes) by calling func1() on the instance passed in.

It takes a myclass reference as its parameter. When the parameter is a base class reference or pointer, you can pass an instance of the derived class to the function. This is the idea of substitutability and is the most important point of virtual methods. The UseIt function doesn't need to know about how many derived classes there are (if any), it just uses the interface specified by the base class, and if derived classes want to do something different they can without you having to change the UseIt method.

So in main(), UseIt is called twice. The first time it is given a, which is an instance of myclass. It works and "myclass::func1" is output through the call to func1(). The second time it is given b, an instance of derivedclass. It works on b and outputs "derivedclass::func1" because even though myc is a myclass reference, it refers to the derivedclass object b, so the derivedclass's version of func1() is called.

You can do the same thing with 7stud's example by adding this function:

Code:

---

void IdentifyAnimal(Animal* ptr)
{
  ptr->identify();
}

---

and calling it from main.