Start Visual Studio 2012 and create a new CLR Console Application project named BigBank.

On the Project menu, click Add New Item.

In the Add New Item dialog box, in the pane on the left, select Visual C++, and then, in the center pane, click Header File (.h).

Toward the bottom of the dialog box, in the Name box, type BankAccount.h, and then click Add.

Define the BankAccount class as follows:

#pragma once

using namespace System;

ref class BankAccount
{
public:
    BankAccount(String ^holder);
    void Credit(double amount);
    void Debit(double amount);
    double GetBalance();
private:
    String ^accountHolder;
    double balance;
};

Repeat steps 2 through 4, but this time add a new C++ source file named BankAccount.cpp to the project.

Type the following code in the source file to implement the BankAccount class:

#include "stdafx.h"
#include "BankAccount.h"

BankAccount::BankAccount(String ^holder)
: accountHolder(holder), balance(0.0)
{
}

void BankAccount::Credit(double amount)
{
    balance += amount;
}

void BankAccount::Debit(double amount)
{
    balance -= amount;
}

double BankAccount::GetBalance()
{
    return balance;
}

Build the application and fix any compiler errors.

Continue using the project from the previous exercise.

Add a new header file to the project named CurrentAccount.h.

Type the following code in the header file to define the CurrentAccount class:

#pragma once

#include "BankAccount.h"

ref class CurrentAccount : BankAccount
{
public:
    CurrentAccount(String ^holder, double limit);
    void ChangeOverdraftLimit(double newLimit);
    double GetOverdraftLimit();
private:
    double overdraftLimit;
};

Notice the #include “BankAccount.h” directive. This directive is required because BankAccount is the base class of CurrentAccount. The compiler needs to know how BankAccount is defined to compile the CurrentAccount class.

Also notice that the CurrentAccount constructor takes two parameters; the first parameter initializes the account holder’s name (defined in BankAccount), and the second initializes the overdraftLimit (defined in CurrentAccount).

Add a new C++ source file to the project named CurrentAccount.cpp.

Type the following code in the source file to implement the CurrentAccount class:

#include "stdafx.h"
#include "CurrentAccount.h"

CurrentAccount::CurrentAccount(String ^holder, double limit)
    : BankAccount(holder), overdraftLimit(limit)
{
}

void CurrentAccount::ChangeOverdraftLimit(double newLimit)
{
    overdraftLimit = newLimit;
}

double CurrentAccount::GetOverdraftLimit()
{
    return overdraftLimit;
}

The most important thing to note about this code is the CurrentAccount constructor. The member initialization list includes the syntax BankAccount(holder). This calls the constructor in the base class, BankAccount, to initialize inherited data members. If you take a look in BankAccount.cpp, you’ll see that the BankAccount constructor requires a String^ parameter to set the account holder’s name. The balance is always set to 0 initially.

Add a header file to the project named SavingsAccount.h.

Add the following declaration for the SavingsAccount class to the file:

#pragma once

#include "BankAccount.h"

ref class SavingsAccount : BankAccount
{
public:
     SavingsAccount(String ^holder);
     static void SetInterestRate(double rate);
     static double GetInterestRate();

private:
     static double interestRate;
};

Add a source file to the project named SavingsAccount.cpp.

Add the following code to the file to implement the SavingsAccount class:

#include "stdafx.h"

#include "SavingsAccount.h"

SavingsAccount::SavingsAccount(String ^holder) : BankAccount(holder) { }

void SavingsAccount::SetInterestRate(double rate)
{
     interestRate = rate;
}

double SavingsAccount::GetInterestRate()
{
     return interestRate;
}

Build the application and fix any compiler errors.

Continue using the project from the previous exercise.

Open BigBank.cpp and add #includes for the CurrentAccount and SavingsAccount header files.

#include "CurrentAccount.h"
#include "SavingsAccount.h"

Delete the “Hello World” line from main. Add code to create a CurrentAccount object and exercise it.

CurrentAccount acc("Me", 2000.0);
acc.Credit(100.0);

double balance = acc.GetBalance();
double overdraft = acc.GetOverdraftLimit();

Console::WriteLine("Balance: {0}", balance);
Console::WriteLine("Overdraft: {0}", overdraft);

You can see that the CurrentAccount object gives you access to the Credit and GetBalance member functions from Account. It also gives you access to its own GetOverdraftLimit function.

Add code to main to create a SavingsAccount.

SavingsAccount::SetInterestRate(2.5);
SavingsAccount sacc("You");
double rate = sacc.GetInterestRate();

Console::WriteLine("Interest rate: {0}", rate);

Build and run the application.

You should see the interest rate printed, showing that you can access a static member through either the class name or through an object.

Build and run the application.

You should see output similar to this:

Balance: 100
Overdraft: 2000
Interest Rate: 2.5

Continue using the project from the previous exercise.

Open BankAccount.h and change the BankAccount class definition by adding the abstract keyword.

ref class BankAccount abstract
{
  ...
};

Open BigBank.cpp to edit the main function for the application.

Inside the main function, try to create a BankAccount object as follows:

BankAccount genericAccount("Fred");

IntelliSense flags an error, which confirms the fact that you cannot create instances of an abstract class.

Delete the statement you created in Step 4.

Continue using the project from the previous exercise.

Open BankAccount.h and add the following public function declarations to the BankAccount class:

// Derived classes can override this function
virtual String ^ToString() override;
// Derived classes must override this function
// You can use '=0' instead of 'abstract'
virtual bool CanDebit(double amount) abstract;

Open BankAccount.cpp and implement the ToString function as follows:

String ^BankAccount::ToString()
{
    String ^result = gcnew String("Account holder: ");
    result = String::Concat(result, accountHolder);
    result = String::Concat(result, ", Balance: ");
    result = String::Concat(result, balance.ToString());
    return result;
}

Observe the use of the String::Concat function, which is used for joining strings together.

Modify the Debit member function as follows:

bool BankAccount::Debit(double amount)
{
    if (CanDebit(amount))
    {
        balance -= amount;
        return true;
    }
    else
    {
        return false;
    }
}

Notice that Debit now calls CanDebit to verify that the debit is allowed. CanDebit isn’t implemented in BankAccount, but all derived classes are obliged to provide this function. At run time, the correct version of CanDebit is called depending on the type of bank account being used for the debit operation—polymorphism in action! We have also changed the return type of Debit so that calling code can determine whether the debit worked.

Change the prototype for Debit in BankAccount.h so that it returns a bool.

Open CurrentAccount.h and add the following public function declarations to the Current Account class:

// Choose to override ToString
virtual String ^ToString() override;
// Have to override CanDebit
virtual bool CanDebit(double amount) override;

Notice the use of the override keyword. This instructs the compiler that you are intending to override a function from the base class and haven’t just added a function that happens to look exactly the same.

Open CurrentAccount.cpp and implement the ToString function as follows:

String ^CurrentAccount::ToString()
{
    String ^result = BankAccount::ToString();
    result = String::Concat(result, ", Overdraft Limit: ");
    result = String::Concat(result, overdraftLimit.ToString());
    return result;
}

The BankAccount::ToString() syntax calls the ToString function in the base class (BankAccount). This call returns a string containing the account holder’s name and balance. We concatenate the overdraftLimit value to this string and return it.

Still in CurrentAccount.cpp, implement the CanDebit function as follows:

bool CurrentAccount::CanDebit(double amount)
{
    return (amount <= GetBalance() + overdraftLimit);
}

There are two things to note about this code. First, we need to call the GetBalance function to get the current balance. Just because we inherit from BankAccount doesn’t mean that we can access its private balance member.

Second, notice the way in which the return statement is written, returning the result of the expression directly. We could have used an if statement to check the condition and return true or false, but this code is shorter while being no less readable, and that is something that C++ coders like.

Open SavingsAccount.h and add the following public function declaration to the Savings Account class:

virtual bool CanDebit(double amount) override;

You are obliged to override CanDebit because it’s a pure virtual function. However, you do not have to override ToString, because the base class (BankAccount) provides a default implementation of this function. The SavingsAccount class chooses not to override ToString.

Open SavingsAccount.cpp and implement the CanDebit function as follows:

bool SavingsAccount::CanDebit(double amount)
{
    return (amount <= GetBalance() / 10);
}

This function makes it possible for the user to withdraw one-tenth of the current balance.

Open BigBank.cpp and replace the existing code in the main function with the following:

Console::WriteLine("Testing the CurrentAccount");
CurrentAccount current("Jane", 100);
current.Credit(500);

// Should be accepted
if (current.Debit(550) == true)
{
     Console::WriteLine("Debit(550) OK");
}
else
{
     Console::WriteLine("Debit(550) failed");
}

// Should be declined
if (current.Debit(100) == true)
{
     Console::WriteLine("Debit(100) OK");
}
else
{
     Console::WriteLine("Debit(100) failed");
}

Console::WriteLine(current.ToString());

Console::WriteLine("
Testing the SavingsAccount");
SavingsAccount savings("Fred");
savings.Credit(500);

// Should be accepted
if (savings.Debit(50) == true)
{
     Console::WriteLine("Debit(50) OK");
}
else
{
     Console::WriteLine("Debit(50) failed");
}

// Should be declined
if (savings.Debit(46) == true)
{
     Console::WriteLine("Debit(46) OK");
}
else
{
     Console::WriteLine("Debit(46) failed");
}

Console::WriteLine(savings.ToString());

return 0;

Build and run the application. Check that the output is what you expect.

Create a breakpoint on the first statement in the main function and then start the application in the debugger. Step through the application one statement at a time, stepping into each function to see which version is called during execution.

Continue using the project from the previous exercise.

Open BankAccount.h and add the following protected function declaration to the BankAccount class:

protected:
    String ^RoutingInstructions(double amount);

Open BankAccount.cpp and add the definition of RoutingInstructions.

String ^BankAccount::RoutingInstructions(double amount)
{
    return "Some string...";
}

Open CurrentAccount.cpp and modify the CanDebit function so that it calls RoutingInstructions. You should not see any warnings from the compiler, because CurrentAccount is allowed to call this function.

bool CurrentAccount::CanDebit(double amount)
{
    String ^details = RoutingInstructions(amount);
    return (amount <= GetBalance() + overdraftLimit);
}

Open BigBank.cpp and try adding a call to RoutingInstructions on either the SavingsAccount or CurrentAccount objects.

IntelliSense flags an error because you are not allowed to call this function from an unrelated class. If you build the project, you will get error C3767 (‘BankAccount::RoutingInstructions’: candidate function(s) not accessible)