C++: Pointer to access methods in derived classes

This entry is part 56 of 61 in the series C++

Since we have gone through one example on a pointer, we make some modifications to our earlier example to use pointer.

We have declared only one ptr_music and with the right referencing, we can use the pointer to access the methods in the derived classes.

When you declare a method as virtual, you are basically setting it up to be overridden by derived classes.

#include <iostream>

using namespace std;

class Music {
    virtual void display();  //setting it up to be overridden

class Rock : public Music {
    void display(); // OVERRIDE!

class Country : public Music {
    void display(); // OVERRIDE!


void Music::display() {

void Rock::display() {

    cout << "Janie Got A Gun By Aerosmith";


void Country::display() {
    cout << "Strawberry Wine by Deana Carter";

int main(int argc, char** argv) {

    Music music;
    Rock rock;
    Country country;

    Music *ptr_music;

    ptr_music = &rock;
    ptr_music->display(); // Call Rock::display()
    cout << endl;
    ptr_music = &country;
    ptr_music->display(); // Call Country::display()

    return 0;


Python Classes and OOP

This entry is part 8 of 8 in the series Python

So we’re back to the example I left in the last lesson:

# bank.py
class Person(object):
    """This is the base class that represents
    a Person
    def __init__(self, first_name, last_name, age):
        self.first_name = first_name
        self.last_name = last_name
        self.age = age

    def get_full_name(self):
        return self.first_name +' '+ self.last_name

class Employee(Person):
    """Since an employee is a Person, we indicate
    that we are a Person by declaring
    class Employee(Person):
    The item inside of () shows we inherit from
    def __init__(self, fname, lname, age, salary, manager):
        Person.__init__(self, first_name=fname, last_name=lname, age=age)
        self.salary = salary
        self.manager = manager

    def get_manager_salary(self):
        return self.manager.salary

    def is_owner(self):
        return True if self.manager is not None else False

class Customer(Person):
    """A Customer is also a Person
    which means we also have a first and last name
    as well as an age
    def __init__(self, first_name, last_name, age, bank_account):
        Person.__init__(self, first_name, last_name, age=age)
        self.bank_account = bank_account

    def get_account_balance(self):
        return self.bank_account.balance

    def deposit(self, amount):
        # We return the new account balance
        return self.bank_account.increase_cash(amount)

    def spend(self, amount):
        return self.bank_account.decrease_cash(amount)

class BankAccount(object):
    """A class that represents a bank
    def __init__(self, balance, manager):
        self.balance = balance
        self.manager = manager

    def decrease_cash(self, spent_money):
        self.balance -= spent_money
        return self.balance

    def increase_cash(self, money):
        self.balance += money
        return self.balance

if __name__ == '__main__':
    bank_manager = Employee('Scrooge', 'McMuffins', salary=1000000, age=99, manager=None)
    rich_bank_account = BankAccount(1000, bank_manager)
    rich_customer = Customer('Rich', 'Person', age=205, bank_account=rich_bank_account)

    print 'The bank manager for your bank is %s'%(bank_manager.get_full_name())
    print 'Your account has $%d in it'%(rich_bank_account.balance)

    interest_payment = 2500
    print '%s\'s account earns $%d of interest'%(rich_customer.get_full_name(), interest_payment)
    new_balance = rich_bank_account.increase_cash(interest_payment)
    print '%s\'s new balance is $%d'%(rich_customer.get_full_name(), new_balance)
    print '%s\'s age is %d years old'%(rich_customer.get_full_name(), rich_customer.age)

    print '%s spends a little money'%(rich_customer.get_full_name())
    print '%s now has $%d'%(rich_customer.get_full_name(), rich_customer.get_account_balance())

    # He has the same mean bank manager as the rich person!
    poor_account = BankAccount(10, manager=bank_manager)
    poor_customer = Customer('Poor', 'Person', 105, poor_account)

    print '%s starts with $%d'%(poor_customer.get_full_name(), poor_account.balance)
    print '%s steals money from %s'%(bank_manager.get_full_name(), poor_customer.get_full_name())
    print '%s now only has $%d'%(poor_customer.get_full_name(), poor_customer.get_account_balance())

Here I’m going to explain each part in detail, enough detail that you’ll hopefully be able to follow along and understand what classes are used for and how to use them.

Let’s first get some basic terminology out of the way.  Class is simply the blueprint of an object, where a class is the code that describes how an object should behave, and an object is a single instance.

# person.py
from bank import Person

zach = Person('Zach', 'Hilbert', 109)
slim = Person('Slim', 'Jim', 25)

# zach is an instance of a Person
print 'My name is ', zach.get_full_name()
print 'But his name is', slim.get_full_name()

Here is an example using Person from bank.py.  The first line of code: from bank import Person, simply says, from the bank module (ie. bank.py), import the Person class.  Then we use Person to create zach.  zach is an instance of Person.  slim is also an instance of Person.  Each instance of person has the ability to utilize the methods of Person (functions of class).

class Person(object):
    """This is the base class that represents
    a Person
    def __init__(self, first_name, last_name, age):
        self.first_name = first_name
        self.last_name = last_name
        self.age = age

    def get_full_name(self):
        return self.first_name +' '+ self.last_name

In the Person class, we have 2 methods, __init__ and get_full_name.  get_full_name provides us a simple way to concatenate a person’s first and last names without having to write this every time we want their name.  The __init__ method is called a constructor, because it is what is called when you construct an instance of the class Person.

When we call zach = Person(‘Zach’, ‘Hilbert’, 109), Person() is instantiating the Person class and assigning the object to zach, which is an instance of Person.  When you call Person(‘Zach’, ‘Hilbert’, 109), __init__ gets called with ‘Zach’ as first_name, ‘Hilbert’ as last_name, and 109 as age.  For each method in a class, self is also passed in as a reference to the current object, so anytime you call self.<method/property>, it calls the data from that instance.  You can see this with zach and slim.  In zachself.first_name contains ‘Zach’, but slim contains ‘Slim’ for self.first_name.

The constructor of a class allows us to set necessary properties up front that may be use later.  All other methods can be created for use as necessary.  Employee and Customer inherit from Person, because they are people too, but both Employee and Customer have different properties and implementations.  Employee has a salary and a manager, who happens to be another employee, and Customer has a bank account which is a class itself.

These classes allow us to represent real-world objects that we might need to manipulate and represent in an application.  You can create as many people, employees, customers, and bank accounts as you want/need (as long as you have enough memory).

Often times you will have a database that saves information for each of these, and when you have customer ‘zach’ log into your application, your code gets zach’s information and bank account information and instantiates their respective classes to work with the zach object.  You might have lots of these objects and they can interact with each other as you need.

The exact implementation isn’t important here.  What is important is to understand that classes and objects help developers create applications that mimic real-world scenarios, and this is how many applications are built and used.

Beneath all of the classes you can see the use of each class and how each instance contains is own, separate data, as well as how these classes might be used to create a basic program.

Now that we have some of this more foundational material out of the way, I’ll focus more time on showing more realistic examples and implementations.

C#: Generic classes

This entry is part 63 of 71 in the series C#

We have looked at generic method but in C#, generic classes are also used widely.

Generic classes allow operations that are not specific to a particular data type.  Usually, those data types are of type integer or string.

If you look at programming literature related to WPF, you will come across this symbol <> quite frequently.

The symbol <> actually denotes either generic method, class or generic interface.

Generic classes are used commonly in WPF such as this ObservableCollection class where it is used to track items in a list or combo box.

using System;

class Mix<T,U>
    T val1;
    U val2;

    public Mix(T t, U u)
        // The field has the same type as the parameter.
        this.val1 = t;
        this.val2 = u;

    public void Write()

    public void Write1()
        Console.WriteLine("I have " + this.val1 + " " + this.val2);

class Program
    static void Main()
        Mix<int, int> m1 = new Mix<int, int>(5, 6);
        Mix<int, string> m2 = new Mix<int, string>(5,"cats");

In this example, the class Mix will be able to take in either integers or strings.  In the class declaration, we use <T,U> and in fact they can be any letter or combination of letters.