OOPs, I did it again.... lol....

I thought it was funny..... Anyways....

Object Oriented Programmers = Engineers?

Objects - bits of code that should be able to be re implemented, reused, and manipulated at will.... = nuts and bolts? wood? electrical wires?

Object oriented programmers - software engineers


In programming class, what did I learn about? I learned about classes, arrays, enums, all kinda of data types, structures, functions, loops.....

But, what didn't we learn (well they tried, but didn't put enough emphasis on?)

We didn't learn how to create object oriented programs. Why is it so hard for me to think in an object oriented manner?

Right now I have a program, my first big one, running on 2700 lines of code, which has about 10 classes in it... that can't be good? It is mainly procedural...

I understand inheritence, that part is easy, but like, how do classes use each other? How do they work together? theyre seperate objects....

Anyone have any real helpful insight into OOP?

Object oriented programming is about treating things as objects. Consider an object such as a box. YOu can look at it and get all kinds of information from it. It's dimensions, it's color, it's material, it's contents. You wouldn't go and get this information from something unrelated.
In an OOP program we can cobine all of this information into a class and once we create an instance of that class we can access all the information about that class by using member variables and meathods of that class.
for example we could call a meathod of a box class to get it's color and compare that color to another box object.

Code:

---

if (Box1.GetColor()==Box2.GetColor())

---

A class can be used as a "black box". You don't need to know how meathods work only what they do an what they return or what private meathods/variables of the class do, you just need to know the class's interface and you can interact with that object.
Don't other use OOP, use it in situations where creating a class makes it easier to understand a problem or more convieniant. You don't have to make a class for everything.

Perhaps you should learn some object oriented design as well.

Simply throwing a few unplanned classes into a program doesn't produce a well designed program which uses OOP to its best effect.

> It is mainly procedural...
Yep, that's it exactly - a complete lack of a design.

> I understand inheritence,
In the same way that understanding putting fuel into a car will make it go, but it doesn't make you a driver.

Here is what I have so far for my game, in terms of object oriented programming

I have a class GameWorld, its responsiblities are only to handle coordinates of the game world and to communicate with the class Mobiles, mobiles sends coordinates to GameWorld...

There are multiple instances of Mobile, here is where the inheritence comes in, Mobiles is a shell, I'm either going it into 2 sections (NPC and Player mobiles) and then add more instances of Mobile::NPC (for different units and such) or, just create a mess of Mobiles::StarFighter Mobiles:: Player Mobiles::StarDefender....


What do you think?

Here it is, Please judge and make suggestions

class GameWorld

Responsibilities: Handle coordinates and other global world information

Communicates with: Mobiles, Statics

class Mobiles

Responsibilities: Tells GameWorld where each inherited mobile is, holds mobile info. Recieves information from Statics (collision detection variables, etc)

Communicates with: GameWorld, Statics

class Statics

Responsibilities: Holds info for static objects (Planets, stars, asteroids), passes info to GameWorld, Sends collision detection information variable to Mobiles

Communicates with: GameWorld, Mobiles

Code:

---

class GameWorld
{
public:
        int SizeX;
        int SizeY;
        int SizeZ;
        void GetMobileLocation(void)
        {
        }
        void GetStaticLocation(void)
        {
        }
};

class Mobiles
{
public:
        int MLocationX;
        int MLocationY;
        int MLocationZ;
        void GetCollisionInfo(void)
        {
        }
};

class Statics
{
public:
        int SLocationX;
        int SLocationY;
        int SLocationz;
        void InitCollisionInfo(void)
        {
        }
};

---

But aren't Mobiles and Statics essentially just things inside of the GameWorld Class, so actually I guess it could go like this: GameWorld->Objects->Statics and Mobiles... Right? Then each static and mobile could pass collision detection info to objects and have it handle all that...

But technically, the only thing that needs to know collision information is mobiles... GameWorld doesn't necessarily need to know, right? So confused...

Quote:

---

I understand inheritence, that part is easy, but like, how do classes use each other? How do they work together? theyre seperate objects....

---

Here are some examples:

(Note: don't let vectors or other STL containers and their notation scare you. A vector is similar to an array except it doesn't have a fixed size, so you can add as many elements to it as you want. Typically, you add another element using push_back(), which adds the element to the end of the vector. In addition, the notation tells you what's in the vector, e.g.:

vector<int> myInts;

The vector, which remember is like an array, can contain integers. Here's another one:

vector<Card> myCards;

The vector can contain Card objects. Finally,

vector<Card*> deck;

The vector can store pointers to Card objects.)

A Deck of Card's that can be shuffled, displayed, and dealt.

Code:

---

#include <iostream>
#include <ctime> //time()
#include <vector>
#include <algorithm> //random_shuffle()
using namespace std;

class Card
{
public:
        Card(int rank_, int suit_)
        {
                rank = rank_;
                suit = suit_;
        }
       
        Card()
        {
                rank = suit = 0;
        }

        //To be able to cout<< Card(s):
        friend ostream& operator<<(ostream& out, const Card* aCard);
        friend ostream& operator<<(ostream& out, const vector<Card*>& aHand);

private:
        int rank;
        int suit;
};       

//To cout<< one Card:
ostream& operator<<(ostream& out, const Card* aCard)
{
        switch (aCard->rank)
        {
        case 2:
        case 3:
        case 4:
        case 5:
        case 6:
        case 7:
        case 8:
        case 9:
        case 10:
                cout<<aCard->rank;
                break;
        case 1:
                cout<<"Ace";
                break;
        case 11:
                cout<<"Jack";
                break;
        case 12:
                cout<<"Queen";
                break;
        case 13:
                cout<<"King";
                break;
        default:
                cout<<"error";
        }
       
        switch(aCard->suit)
        {
        case 1:
                cout<<" of Clubs";
                break;
        case 2:
                cout<<" of Diamonds";
                break;
        case 3:
                cout<<" of Hearts";
                break;
        case 4:
                cout<<" of Spades";
                break;
        default:
                cout<<"error";
        }

        return out;
               
}

//A function that enables you to cout<< a vector of
//Card's(either a hand or a deck).  It's the same function as for
//displaying a single card, but with a for loop to go through the
//whole vector:
ostream& operator<<(ostream& out, const vector<Card*>& aHand)
{
        for(int i = 0; i < aHand.size(); i++)
        {
                switch (aHand[i]->rank)
                {
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 9:
                case 10:
                        cout<<aHand[i]->rank;
                        break;
                case 1:
                        cout<<"Ace";
                        break;
                case 11:
                        cout<<"Jack";
                        break;
                case 12:
                        cout<<"Queen";
                        break;
                case 13:
                        cout<<"King";
                        break;
                default:
                        cout<<"error";
                }
               
                switch(aHand[i]->suit)
                {
                case 1:
                        cout<<" of Clubs";
                        break;
                case 2:
                        cout<<" of Diamonds";
                        break;
                case 3:
                        cout<<" of Hearts";
                        break;
                case 4:
                        cout<<" of Spades";
                        break;
                default:
                        cout<<"error";
                }
               
                cout<<endl;
               
                //Prevents scrolling off the screen:
                if( (i != 0) && (i%20 == 0))
                {
                        cout<<"Continue? <Hit Return>";
                        cin.get();
                        cout<<endl;
                }
        }

        return out;
}


class Deck
{
public:
        Deck()
        {
                for(int i=1; i <= 13; i++)
                {
                        for(int j=1; j <= 4; j++)
                        {
                                //Add a card to the end of the deck member variable:
                                deck.push_back(new Card(i, j));
                        }
                }


                delt = 0;
        }
       
        ~Deck()
        {
                //Delete the memory allocated with new:
                for(vector<Card*>::iterator i = deck.begin(); i != deck.end(); i++)
                {
                        delete *i;
                }
        }
       
        void showDeck()
        {
                cout<<deck<<endl;
        }

        void shuffle()
        {
                //Seed random number generator with current time:
                srand(time(0));
               
                //Shuffle deck:
                random_shuffle(deck.begin(), deck.end());
               
                //After shuffling, set the number of cards dealt back to 0:
                delt = 0;
        }
       
        void deal(const int numCards, vector<Card*>& theHand)
        {
                for(int i=0; i<numCards; i++)
                {
                        if(delt < 52)
                        {
                                //No cards are actually delt from the deck: pointers to Card's
                                //in the deck are put in the Hand instead, and the Cards all stay in the
                                //deck.  The member variable 'delt' is advanced from the top of the
                                //deck down into the deck as the cards are delt, and it marks where
                                //the next card is.
                                theHand.push_back(deck[delt]);
                                ++delt;
                        }
                        else
                                theHand[i] = 0;
                }
        }
       
        //A function to cout<< the 'deck' member variable
        //(uses same friend function as Card):
        friend ostream& operator<<(ostream& out, const vector<Card*>& deck);
       
       
private:
      //A vector of Card pointers is similar to an array of Card pointers:
        vector<Card*> deck;
       
        int delt;
};


int main()
{
       
        Deck myDeck;
        myDeck.showDeck();
        myDeck.shuffle();

        vector<Card*> player1;
        vector<Card*> player2;
        myDeck.deal(5,player1);
        myDeck.deal(5,player2);

        cout<<player1<<endl<<endl
                <<player2<<endl;


        return 0;
}

---

Ducks and Inheritance:

Code:

---

#include<iostream>
using namespace std;

class Duck
{
public:
        virtual void species() = 0;
};

////////////////////////////
class Sound
{
public:
        virtual void speak() = 0;
};

class Quack: public Sound
{
private:
        void speak()
        {
                cout<<"Quack, quack."<<endl;
        }
};

class Squeak: public Sound
{
private:
        void speak()
        {
                cout<<"Squeak, squeak."<<endl;
        }
};
//////////////////////////////


class Mallard : public Duck
{
public:
        Mallard()
        {
                Q = new Quack;
        }

        ~Mallard()
        {
                delete Q;
        }

        void species()
        {
                cout<<"Mallard"<<endl;
        }

        Quack* getSound()
        {
                return Q;
        }

private:
        Quack* Q;
};


class RubberDuck : public Duck
{
public:
        RubberDuck()
        {
                S = new Squeak;
        }
        ~RubberDuck()
        {
                delete S;
        }

        void species()
        {
                cout<<"Rubber"<<endl;
        }

        Squeak* getSound()
        {
                return S;
        }

private:
        Squeak* S;
};

//Because the following function has parameters that are base
//class pointers it can handle any Duck that makes any Sound.
void operateDuck(Duck* const pDuck, Sound* const pSound)
{
        pDuck->species();
        pSound->speak();
}
       
int main()
{
        Mallard myDuck;
        RubberDuck yourDuck;

        operateDuck(&myDuck, myDuck.getSound());
        cout<<endl;
        operateDuck(&yourDuck, yourDuck.getSound());
       
        return 0;
}

---

That is what I vaguely remember of the first design problem in the book "Head First Design Patterns":

http://www.amazon.com/exec/obidos/tg...books&n=507846

It seemed like a really interesting and easy to read book, although it's written for Java. If you note that an "interface" in Java is the same thing as a pure abstract class in C++(i.e. a class with all virtual functions and no definitions for the funtions), then you should be able to understand at least the first chapter if you want to take a look at it in the bookstore some time.

Lol, Havn't read through it yet, but....

Inheritence with ducks - Cute :D

Ahh.....STL is a beautiful thing.

A lifesaver.

As long as your life doesn't depend on having any spare RAM ;)

The idea behind the design of the Duck class structure:

1) The designer first used straight inheritance, and the Duck base class implemented the speak() function to quack. The derived classes all inherited the same speak() function. The problem: not all Ducks speak() the same, RubberDuck's don't quack, they squeak.

2) The designer quickly made some changes to the Duck class to make speak() a virtual function and had each Derived class override speak() to get the proper noise for each species of Duck. Mallards would quack and RubberDuck's would squeak. The problem: if you anticipate having to alter the the noise each Duck makes in the future, you have to dig through every derived Duck class and make the specific changes to the overriding functions. If there are a lot of derived Duck classes, that can be a real chore to maintain.

3) The resulting design is one that extracts the methods that the programmer anticipates will require alteration in the future, i.e. speak(). That method was extracted from the Duck class and made into separate Quack and Squeak classes. Then each derived Duck class contains a member that is a Quack or Squeak object which represents the sound they make.

Future changes to the speak() methods will be much easier to maintain because they can be altered in the set of classes that represent the sounds ducks make, i.e. Quack and Squeak, and all of the Duck species that contain those objects will automatically reflect the changes. If you end up having 30 different noises that Duck's make, it will still be a pain to alter all 30 noises if that is required--but that's better than having to go through potentially 100's of derived Duck classes and changing the overridden speak() function in each one of them.

Quack and Squeak were also given a common base class Sound so that a Sound base class pointer could be used to point to both Quack and Squeak objects. Then, using the base pointer to call speak() results in the appropriate version of speak() being called (that's what "polymorphism" is all about!). The operateDuck() function demonstrates how that works.

the duck example is a good one. i have found that it is alot easier to demonstrate oop with the same type of small programs with several simple classes....

this professor i had once (who i think smoked a ton of crack before every class) anyhow though, he said that oop is like garbage and recycling in that you reduce, reuse, recycle... ?? yeh i dont know either.. but he went on...

reduce - keep your classes small and specialized, and the member functions specialized. if it looks like it is getting bloated, it probably is

reuse - you need to design with reuse, interuse in mind. just like in the duck example, inheritance and implicit casts(to base classes) are quite important for easy development

recycle - this really didnt have an answer. he just said it sounded good. someone asked him if it meant using delete, he said no, and that was the end of that..

hopefully you are as confused as I am now... lol.. the best way to figure it out is to make a bunch of classes that do nothing but print a little message and start creating derived classes, and creating functions that take a base class, make some virtual functions, play around with multiple inheri... etc... see what they do.. but do this with small classes... its too tempting to get into a big program and then you are just changing this and that until it works without really knowing what is going on....

Question, why do we virtualize functions? What does this accomplish? Forgive me for my noobness in C++.

Nevermind, answered that question:

Quote:

---

A virtual function is a member function that you expect to be redefined in derived classes. When you refer to a derived class object using a pointer or a reference to the base class, you can call a virtual function for that object and execute the derived class's version of the function.

---

MSDN 4tw

Also, with this bit of code, are we just connecting Mallard to the parent class Duck?

Code:

---

class Mallard : public Duck

---

1.When you vitualize functions that means the derivied class function with the same name will overwrite the base class function.

2. You are inheriting publicly from the Duck class which basically means you don't change any of the data hiding from the base class. If you were to say make it protected Duck. Only the class and derivied classes that derivied could call the public functions in the base class.

So in theory, if it was protected, If I had a stick (another object)and poked the Mallard, it wouldn't quack, because only duck can make it quack :d

And another thing. What if we wanted the duck class to hold a few more things, such as, male/female, color, etc...?

Do we make virtual functions for these that will be overridden by classes that inherit duck? Or do we just create variables for these, since they don't actually function, they just declare an amount?

Hi,

Here is a scaled back demonstration of what polymorphism is:

Code:

---

#include<iostream>
#include<vector>
using namespace std;

class Duck
{
public:
        virtual void speak()
        {
                cout<<"I'm a Duck."<<endl;
        }
};

class Mallard : public Duck
{
public:
        virtual void speak()
        {
                cout<<"Quack, quack."<<endl;
        }
};

class RubberDuck : public Duck
{
public:
        virtual void speak()
        {
                cout<<"Squeak, squeak"<<endl;
        }
};


void operateDucks(vector<Duck*> Ducks)
{
        for(int i=0; i<Ducks.size(); i++)
        {
                //This is where the interesting stuff happens:
                Ducks[i]->speak();
        }
}

int main()
{
        Duck aDuck;
        Mallard myDuck;
        RubberDuck yourDuck;
       
        //Put their addresses in a vector(which is like an array):
        vector<Duck*> Ducks;
        Ducks.push_back(&aDuck);
        Ducks.push_back(&myDuck);
        Ducks.push_back(&yourDuck);

        operateDucks(Ducks);

        return 0;
}

---

If you look at the output from the program, you will see that somehow the operateDucks() function was able to call the correct version of the speak() function for each pointer in the vector--even though all the pointers in the vector are Duck pointers.

Why didn't the function call the version of speak() in the Duck class everytime? The answer is polymorphism. If you delete the keyword virtual in front of the speak() function in the Duck class, see what happens.

I think I understand, polymorphism is when the inherited class changes the member functions... Like when mallard speaks, it changes speak from "I'm a duck," to "quack, quack," or "squeek, squeek."

I can already see how useful it is!

*imagines all the fun programming jokes you can make with polymorphism*

Quote:

---

Also, with this bit of code, are we just connecting Mallard to the parent class Duck?

Code:

---

class Mallard : public Duck

---

---

That's called inheritance. That means Mallard inherits the members and functions from the Duck class. Here is an example:

Code:

---

#include<iostream>
using namespace std;

class Duck
{
public:
        void speak()
        {
                cout<<"I'm a Duck."<<endl;
        }
};

class Mallard : public Duck
{
public:
        void greeting()
        {
                cout<<"Hi, I'm a Mallard."<<endl;
        }
};

int main()
{
        Mallard M;
        M.greeting();

        M.speak();

        return 0;
}

---

Notice how a Mallard could call the speak() function even though there is no speak() function declared in Mallard.

I understand now...

*feels enlightened*

Now, when you Mallard inherits Ducks speak ability(function), mallard does it a bit differently, so it uses polymorphism to change exactly what the speak ability(function) is.

So the two generally come hand in hand.... But of course, not always...


What happens when we have two base classes, and one child inherits both? (real life issue!)
Do we create a super child with ALL of the traits of the parents? or does it meld together? Or do you decide how they mix in your code?

There are three possibilities with respect to functions: overloading, overriding, and hiding.

Overloading occurs when two functions declared in the same scope(that eliminates inherited functions since they are declared in a different scope) have the same name but they have different parameters. The correct function will be called based on what parameters you use.

If a Derived class function has the same name as a Base class function--it doesn't even have to have the same parameters, just the same name--then it hides the Base class function.

If a Derived class function has the same name and parameters as a Base class function, and the Base class function is declared virtual, then the Derived class function is said to override the Base class function, and the version in the Derived class will be called if you use a Base class pointer to call the function and the Base class pointer points to a Derived class object.

I see, so the generally complex subject can be melded down into how it works in the real world, with people, animals, humans...

We've created a monster.

I'm definately claiming that quote in this context

Overloading occurs when you inherit blue AND green eyes, I guess blue-green makes turqoise eyes!

Overriding occurs when your kid dyes their hair blue even though they got natural red hair (those silly emo kids!), still have hair, but it has polymorphisized!

hiding occurs when you inherit big feet instead of little feet, you don't have little feet at all any more, you got those big ones...

Quote:

---

What happens when we have two base classes, and one child inherits both? (real life issue!)
Do we create a super child with ALL of the traits of the parents? or does it meld together? Or do you decide how they mix in your code?

---

Thats called multiple inheritance and the Derived class inherits all the member variables and functions from each of the Base classes. Here is an example:

Code:

---

#include<iostream>
using namespace std;

class Duck
{
public:
        void speak()
        {
                cout<<"I'm a Duck."<<endl;
        }
};

class Biped
{
public:
        void walk()
        {
                cout<<"Waddle, waddle."<<endl;
        }
};

class Mallard : public Duck, public Biped
{
        //empty
};

int main()
{
        Mallard M;
        M.speak();
        M.walk();

        return 0;
}

---

If we ever decided to turn the human genome into written code... I believe it would be in C++ :D

Quote:

---

Overloading occurs when you inherit blue AND green eyes, I guess blue-green makes turqoise eyes!

---

Nope. Overloading doesn't involve inherited functions--read my post again.

Quote:

---

hiding occurs when you inherit big feet instead of little feet

---

Hiding keeps you from calling the inherited function, similar to the way the outer x is hidden by the inner x:

Code:

---

int main()
{
    int x = 10;
    if(true)
    {
          int x = 30;
          cout<<x<<endl;
    }
    return 0;
}

---

There is a way to get around a Derived class hiding an inherited function.

Ahhh, overloading is like learning to speak two new languages then! You can learn spanish and french, theyre both a Language function, but its like

Language(Spanish), Language(French)


So hiding is like, instead of inheriting feet at all, you like, freakin mutate and grow fins! Fins are still ways to move, just, not feet :D

Please forgive my metaphors, they help me understand the subject fully.

I updated the Duck example to get rid of the awkwardness of using the operateDuck() function:

Code:

---

#include<iostream>
using namespace std;

class Sound;

class Duck
{
public:
        Duck(Sound* p);
        Duck();
       
        virtual void species() const = 0;
        void operateDuck();  //see definition after main()
       
private:
        Sound* pSound;
};

////////////////////////////
class Sound
{
public:
        virtual void speak() = 0;
};

class Quack: public Sound
{
private:
        void speak()
        {
                cout<<"Quack, quack."<<endl;
        }
};

class Squeak: public Sound
{
private:
        void speak()
        {
                cout<<"Squeak, squeak."<<endl;
        }
};
//////////////////////////////

class Mallard : public Duck
{
public:
        Mallard(Sound* p) : Duck(p)
        {}
        Mallard()
        {}

        void species() const
        {
                cout<<"Mallard"<<endl;
        }

};

class RubberDuck : public Duck
{
public:
        RubberDuck(Sound* p) : Duck(p)
        {}
        RubberDuck()
        {}
       
        void species() const
        {
                cout<<"Rubber"<<endl;
        }
};

int main()
{
        Quack Q;
        Squeak S;

        Mallard myDuck(&Q);
        RubberDuck yourDuck(&S);

        myDuck.operateDuck();
        cout<<endl;
        yourDuck.operateDuck();


        return 0;
}

////////////////////////
Duck::Duck(Sound* p)
{
        pSound = p;
}
Duck::Duck()
{}

void Duck::operateDuck()
{
        this->species();

        pSound->speak(); 
}
///////////////////////////

---

It's so complex yet so simple at the same time, concepts are simple, syntax is so confusing though...

I understand the whole thing except for the Constructors and Destructors, never really payed attention to those in school, i'll read over them then... Also, the parameters that operateDuck takes, I kindof don't understand them. I know that they take Ducks* and a myDuck.getSound() function.. but what do these data types mean?

Code:

---

void operateDuck(Duck* const pDuck, Sound* const pSound)

---

I know that Duck* means we need a pointer to duck, but what is the const pDuck part? I know Sound* means we need a pointer to sound, but what does const pSound mean?

Quote:

---

Originally Posted by Shamino

It's so complex yet so simple at the same time, concepts are simple, syntax is so confusing though...

I understand the whole thing except for the Constructors and Destructors, never really payed attention to those in school, i'll read over them then...

---

Constructors are required to create objects of the class. Destructors are used to do some tidying up before an object is destroyed, which happens when an object goes out of scope. For instance, if you use 'new' in a constructor to dynamically allocate some memory for one of the member variables of an object, then you have to be sure to 'delete' it.

[quote]Also, the parameters that operateDuck takes, I kindof don't understand them. I know that they take Ducks* and a myDuck.getSound() function.. but what do these data types mean?

Code:

---

void operateDuck(Duck* const pDuck, Sound* const pSound)

---

Quote:

---

I know that Duck* means we need a pointer to duck, but what is the const pDuck part? I know Sound* means we need a pointer to sound, but what does const pSound mean?

---

I rewrote that function to make it easier to use, but to answer your question, making a function parameter const prohibits the function from changing the parameter. If you know that your function shouldn't change a parameter, then you should declare the parameter const. That way if you make a mistake and accidentally try to change the parameter inside the function, the compiler will flag it as an error and then you can correct the error. On the other hand, if you need to change the parameter inside the function, then don't declare the parameter const.

The more times you look at the syntax and try to figure out what it does, the easier it becomes.

Here is my attempt at an object oriented animal Hierarchy, I'm stuck from here, don't look at the content (what they say) it might be goofy and wrong!...

My questions, How do I go about creating an operate Animal function, I'll end up throwing these into vectors and such, what would my next step from here be?

Code:

---

#include <iostream.h>

class Animals
{
public:
        Animals();
        ~Animals();

        virtual void Movement()
        {
        }
        virtual void Eat()
        {
        }
};

class Mammals : public Animals
{
public:
        Mammals();
        ~Mammals();
                void Movement()
        {
                cout << "I use my legs!" << endl;
        }
                void Eat()
        {
                cout << "I eat anything I can find!" << endl;
        }
};

class Reptiles : public Animals
{
public:
        Reptiles();
        ~Reptiles();
                void Movement()
        {
                cout << "I use my legs and slither!" << endl;
        }
                void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
};

class Birds : public Animals
{
public:
        Birds();
        ~Birds();
                void Movement()
        {
                cout << "I fly for the most part, some of the oddballs walk!" << endl;
        }
            void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }

};

class Amphibians : public Animals
{
public:
        Amphibians();
        ~Amphibians();
                void Movement()
        {
                cout << "I generally crawl with my legs, and slither, AND swim!" << endl;
        }
                void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
};

class Fish : public Animals
{
public:
        Fish();
        ~Fish();
                void Movement()
        {
                cout << "You guessed it, I swim! (some of us get beached though, stupid fat whales!)" << endl;
        }
                void Eat()
        {
                cout << "I eat anything I can find in the water!" << endl;
        }
};

int main()
{
        return 0;
}

---

Are you asking about operator overloading?

1)#include <iostream.h> --> <iostream>

2) Since it looks like you are defining all your functions inside the clase, these also have to be defined:

Code:

---

Animals();
~Animals();

---

Those are just prototypes(the function headers). In addition, the compiler supplies invisible default constructors and destructors that do nothing for you. If you define other constructors, i.e. one's that have parameters, then the compiler won't supply a default constructor, so if you need one you have to include it in the class yourself.

3)

Quote:

---

My questions, How do I go about creating an operate Animal function,

---

The goal is:

a) to write a single function that will accept any derived class object and
b) to have the function call the correct version of the function in the derived class.

To accomplish a) you need to assign your objects to a base class pointer. A base class pointer can point to any derived object. Then you can pass the base class pointers to the function.

To accomplish b) requires "polymorphic" behavior, which also requires a base class pointer that points to a derived object. In addition, it requires that you declare the base class function as virtual. Then, you use the base class pointer to call the virtual function, and the version of the function that is called will correspond to the type of the object that the base class pointer points to.

Code:

---

#include <iostream>
#include <vector>

class Animal
{
public:

        virtual void Movement()
        {
        }
        virtual void Eat()
        {
        }

};

class Mammals : public Animal
{
public:
                void Movement()
        {
                cout << "I use my legs!" << endl;
        }
                void Eat()
        {
                cout << "I eat anything I can find!" << endl;
        }
};

class Reptiles : public Animal
{
public:
                void Movement()
        {
                cout << "I use my legs and slither!" << endl;
        }
                void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
};

class Birds : public Animal
{
public:
                void Movement()
        {
                cout << "I fly for the most part, some of the oddballs walk!" << endl;
        }
            void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }

};

class Amphibians : public Animal
{
public:
                void Movement()
        {
                cout << "I generally crawl with my legs, and slither, AND swim!" << endl;
        }
                void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
};

class Fishes : public Animal
{
public:
                void Movement()
        {
                cout << "You guessed it, I swim! (some of us get beached though, stupid fat whales!)" << endl;
        }
                void Eat()
        {
                cout << "I eat anything I can find in the water!" << endl;
        }
};

void operateAnimals(vector<Animal*> Animals)
{
        for(int i=0; i<Animals.size(); i++)
        {
                //This is where the interesting stuff happens:
                Animals[i]->Movement();
                Animals[i]->Eat();
        }
}


int main()
{
        Animal allAnimals;
        Mammals Mammal;
        Reptiles Reptile;
        Birds Bird;
        Amphibians Amphibian;
        Fishes Fish;

        vector<Animal*> Animals;
        Animals.push_back(&Mammals);
        Animals.push_back(&Reptile);
        Animals.push_back(&Bird);
        Animals.push_back(&Bird);
        Animals.push_back(&Amphibian);
        Animals.push_back(&Fish);

        operateAnimals(Animals);

        return 0;
}

---

Lotsa errors, here they are, when i make it include <iostream> couts and stuff are undeclared, and it seems that it isnt taking vector either?

Code:

---

--------------------Configuration: Practice with OOP - Win32 Debug--------------------
Compiling...
Practice.cpp
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(22) : error C2065: 'cout' : undeclared identifier
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(22) : error C2297: '<<' : illegal, right operand has type 'char [15]'
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(22) : error C2065: 'endl' : undeclared identifier
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(26) : error C2297: '<<' : illegal, right operand has type 'char [27]'
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(83) : error C2065: 'vector' : undeclared identifier
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(83) : error C2059: syntax error : '>'
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(84) : error C2143: syntax error : missing ';' before '{'
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(84) : error C2447: missing function header (old-style formal list?)
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(103) : error C2059: syntax error : '>'
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(104) : error C2065: 'Animals' : undeclared identifier
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(104) : error C2228: left of '.push_back' must have class/struct/union type
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(104) : error C2275: 'Mammals' : illegal use of this type as an expression
        c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(17) : see declaration of 'Mammals'
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(105) : error C2228: left of '.push_back' must have class/struct/union type
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(106) : error C2228: left of '.push_back' must have class/struct/union type
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(107) : error C2228: left of '.push_back' must have class/struct/union type
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(108) : error C2228: left of '.push_back' must have class/struct/union type
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(109) : error C2228: left of '.push_back' must have class/struct/union type
c:\documents and settings\jonathan\my documents\c++ programming\opengl with nehe\nehe tutorials\practice with oop\practice.cpp(111) : error C2065: 'operateAnimals' : undeclared identifier
Error executing cl.exe.

Practice with OOP.exe - 18 error(s), 0 warning(s)

---

Fixed it!

Code:

---

#include <iostream>
#include <vector>

using namespace::std;

class Animal
{
public:

        virtual void Movement()
        {
        }
        virtual void Eat()
        {
        }

};

class Mammals : public Animal
{
public:
                void Movement()
        {
                cout << "I use my legs!" << endl;
        }
                void Eat()
        {
                cout << "I eat anything I can find!" << endl;
        }
};

class Reptiles : public Animal
{
public:
                void Movement()
        {
                cout << "I use my legs and slither!" << endl;
        }
                void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
};

class Birds : public Animal
{
public:
                void Movement()
        {
                cout << "I fly for the most part, some of the oddballs walk!" << endl;
        }
            void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }

};

class Amphibians : public Animal
{
public:
                void Movement()
        {
                cout << "I generally crawl with my legs, and slither, AND swim!" << endl;
        }
                void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
};

class Fishes : public Animal
{
public:
                void Movement()
        {
                cout << "You guessed it, I swim! (some of us get beached though, stupid fat whales!)" << endl;
        }
                void Eat()
        {
                cout << "I eat anything I can find in the water!" << endl;
        }
};

void operateAnimals(vector<Animal*> Animals)
{
        for(int i=0; i<Animals.size(); i++)
        {
                //This is where the interesting stuff happens:
                Animals[i]->Movement();
                Animals[i]->Eat();
        }
}


int main()
{
        Animal allAnimals;
        Mammals Mammal;
        Reptiles Reptile;
        Birds Bird;
        Amphibians Amphibian;
        Fishes Fish;

        vector<Animal*> Animals;
        Animals.push_back(&Mammal);
        Animals.push_back(&Reptile);
        Animals.push_back(&Bird);
        Animals.push_back(&Amphibian);
        Animals.push_back(&Fish);

        operateAnimals(Animals);

        return 0;
}

---

It works!

OMG this is amazing! I can keep narrowing the species and races down, the coding is SO easy now!

I added a Dog class, that inherits mammals, which inherits Animal...

I can now go from dog, to Terrier, hound, poodle

down to Jack Russel Terrier, Coon Hound, Toy poodle!!!

So now I can still use the animal class to access DOG! Freakin amazing!

OOps, I've done it...

End thread.

Code:

---

#include <iostream>
#include <vector>

using namespace::std;
/////////////////////////////////////
class Animal
{
public:
        virtual void Speak()
        {
        }
        virtual void Movement()
        {
        }
        virtual void Eat()
        {
        }
        virtual void Species()
        {
        }

};
/////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////////////////
class Mammals : public Animal
{
public:       
       
                void Movement()
        {
                cout << "I use my legs!" << endl;
        }
                void Eat()
        {
                cout << "I eat anything I can find!" << endl;
        }
                void Species()
        {
                cout << "I'm a Mammal!" << endl;
        }


};

class Reptiles : public Animal
{
public:

                void Movement()
        {
                cout << "I use my legs and slither!" << endl;
        }
                void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
                void Species()
        {
                cout << "I'm a Reptile!" << endl;
        }
};

class Birds : public Animal
{
public:

                void Movement()
        {
                cout << "I fly for the most part, some of the oddballs walk!" << endl;
        }
            void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
                void Species()
        {
                cout << "I'm a Bird!" << endl;
        }

};

class Amphibians : public Animal
{
public:

                void Movement()
        {
                cout << "I generally crawl with my legs, and slither, AND swim!" << endl;
        }
                void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
                void Species()
        {
                cout << "I'm an Amphibian!" << endl;
        }
};

class Fishes : public Animal
{
public:
                void Movement()
        {
                cout << "You guessed it, I swim! (some of us get beached though, stupid fat whales!)" << endl;
        }
                void Eat()
        {
                cout << "I eat anything I can find in the water!" << endl;
        }
                void Species()
        {
                cout << "I'm a Fish!" << endl;
        }
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////


class Dogs :  public Mammals
{
public:
        void Speak()
        {
                cout << "Bark! Bark!" << endl;
        }
};

////////////////////////////////////////////////////////////
void operateAnimals(vector<Animal*> Animals)
{
        for(int i=0; i<Animals.size(); i++)
        {
                //This is where the interesting stuff happens:
                Animals[i]->Species();
                Animals[i]->Movement();
                Animals[i]->Eat();
                Animals[i]->Speak();
                cout << endl;

        }
}
////////////////////////////////////////////////////////////

int main()
{
        Animal allAnimals;
        Mammals Mammal;
        Reptiles Reptile;
        Birds Bird;
        Amphibians Amphibian;
        Fishes Fish;
        Dogs Dog;

        vector<Animal*> Animals;
        Animals.push_back(&Mammal);
        Animals.push_back(&Reptile);
        Animals.push_back(&Bird);
        Animals.push_back(&Amphibian);
        Animals.push_back(&Fish);
        Animals.push_back(&Dog);

        operateAnimals(Animals);
        return 0;
}

---

Example of a Simple Class Hierarchy!

I think this is as object oriented as it gets, lets start from the bottom: We have Poodle, Poodle is a Dog, Dog is a Mammal, Mammal is an Animal.

All animals have skin, can make noise, can move, can eat, and have a species, thus declared in the Animal class. We use like, ultra inheritence and polymorphism to define the poodle class, it inherits alot, and changes only a few things, very cool!

Code:

---

#include <iostream>
#include <vector>

using namespace::std;
/////////////////////////////////////
class Animal
{
public:
        virtual void Skin()
        {
        }
        virtual void Speak()
        {
        }
        virtual void Movement()
        {
        }
        virtual void Eat()
        {
        }
        virtual void Species()
        {
        }

};
/////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////////////////
class Mammals : public Animal
{
public:       
       
                void Movement()
        {
                cout << "I use my legs!" << endl;
        }
                void Eat()
        {
                cout << "I eat anything I can find!" << endl;
        }
                void Species()
        {
                cout << "I'm a Mammal!" << endl;
        }


};

class Reptiles : public Animal
{
public:

                void Movement()
        {
                cout << "I use my legs and slither!" << endl;
        }
                void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
                void Species()
        {
                cout << "I'm a Reptile!" << endl;
        }
};

class Birds : public Animal
{
public:

                void Movement()
        {
                cout << "I fly for the most part, some of the oddballs walk!" << endl;
        }
            void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
                void Species()
        {
                cout << "I'm a Bird!" << endl;
        }

};

class Amphibians : public Animal
{
public:

                void Movement()
        {
                cout << "I generally crawl with my legs, and slither, AND swim!" << endl;
        }
                void Eat()
        {
                cout << "I usually eat meat!" << endl;
        }
                void Species()
        {
                cout << "I'm an Amphibian!" << endl;
        }
};

class Fishes : public Animal
{
public:
                void Movement()
        {
                cout << "You guessed it, I swim! (some of us get beached though, stupid fat whales!)" << endl;
        }
                void Eat()
        {
                cout << "I eat anything I can find in the water!" << endl;
        }
                void Species()
        {
                cout << "I'm a Fish!" << endl;
        }
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
class Dogs :  public Mammals
{
public:
        virtual void Skin()
        {
                cout << "I'm covered in fur!" << endl;
        }
        void Speak()
        {
                cout << "Bark! Bark!" << endl;
        }
};

////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
class Poodles : public Dogs
{
public:
        void Skin()
        {
                cout << "My fur is long and curly!" << endl;
        }
};

////////////////////////////////////////////////////////////
void operateAnimals(vector<Animal*> Animals)
{
        for(int i=0; i<Animals.size(); i++)
        {
                //This is where the interesting stuff happens:
                Animals[i]->Species();
                Animals[i]->Movement();
                Animals[i]->Eat();
                Animals[i]->Speak();
                Animals[i]->Skin();
                cout << endl;

        }
}
////////////////////////////////////////////////////////////

int main()
{
        Animal allAnimals;
        Mammals Mammal;
        Reptiles Reptile;
        Birds Bird;
        Amphibians Amphibian;
        Fishes Fish;
        Dogs Dog;
        Poodles Poodle;

        vector<Animal*> Animals;
        Animals.push_back(&Mammal);
        Animals.push_back(&Reptile);
        Animals.push_back(&Bird);
        Animals.push_back(&Amphibian);
        Animals.push_back(&Fish);
        Animals.push_back(&Dog);
        Animals.push_back(&Poodle);

        operateAnimals(Animals);
        return 0;
}

---

Sorry if I'm overposting, I feel like these examples can help anyone else with the question, Maybe we can get this moved onto a faq board? How woudl I go about doing that? I found this thread INCREDIBLY useful.


I think I'm going to make a dynamic database for Taxonomy and actually allow the user to add in the family/phylum/genus/species/etcetcetc at will, to constantly increase the database and make it larger and larger and larger.

For a practice project, ykno :d