Videos about Object Oriented Programming

Summary

The class CCAccount is created to model a Credit Card Account. It has attributes that correspond to the name of the customer, the balance on the account, and the list of all transactions on the account. This is a simplified example and we do not maintain the full transaction records such as date, time, and merchant. We only keep track of the amount of money during transactions.

The complete code after the first two videos is displayed below:

Video 1: Introduction. Attributes and methods. Private and public specifiers

Video 2: Constructor and destructor

Video 3: Copy assignment

Video 4: Copy constructor. Common memory leaks in copy assignments. Trouble with self-assignments

Video 5: Move assignment and move constructor

Lecture notes and complete code

The code created in these five videos can be accessed below.

// ccaccount.cpp
// compile with:
// c++ ccaccount.cpp -o a -std=c++11 -fno-elide-constructors
// execute with:
// ./a
#include<iostream>
#include<iostream>
 class SN{// Stack Node
 public:
  double content;
  SN* aNext;
 };
 SN* push(SN* oH, double x){
  SN* nN;
  nN=new SN;
  nN->content=x;
  nN->aNext=oH;
  return nN;
 }
 SN* pop(SN* oH){
  if(oH==nullptr){
    return nullptr;
  }
  SN* nextNode;
  nextNode=oH->aNext;
  delete oH;
  return nextNode;
 }
 double readTop(SN* aH){
  if(aH==nullptr){
    return 0.0;
  }
  return aH->content;
 }
 int isEmpty(SN* aH){
  if(aH==nullptr){
    return 1;
  }
  return 0;
 }
 void deleteStack(SN* aH){
  while(aH!=nullptr){
    aH=pop(aH);
  }
 }
 SN* copyStack(SN* aOldHead){
    SN* aNHead=nullptr;
    if(aOldHead!=nullptr){
        aNHead=new SN;
        aNHead->content=aOldHead->content;
        aNHead->aNext=copyStack(aOldHead->aNext);
    }
    return aNHead;
}

class CCAccount{
private:
    double balance;
    SN* aHT;//add. head of the transactions
public:
    std::string cName;//attribute
    CCAccount();
    CCAccount(const CCAccount &);
    CCAccount(CCAccount && );//move construction
    void addCharge(double x);//mutator
    void printStatement() const;//accessor
    void operator=(const CCAccount &);//mutator
    void operator=(CCAccount &&);//move assignment
    double getBalance() const;//accessor
    ~CCAccount();
};
CCAccount::CCAccount(const CCAccount & cF){
    std::cout<< "Copy Constr. from ";
    std::cout<< (long)(&cF)<<" to ";
    std::cout<< (long)(this)<<"\n";
    cName=cF.cName;
    balance=cF.balance;
    aHT = copyStack(cF.aHT);
}
CCAccount::CCAccount(CCAccount && mF){
    std::cout<< "Move Constr. from ";
    std::cout<< (long)(&mF)<<" to ";
    std::cout<< (long)(this)<<"\n";
    cName=mF.cName;
    balance=mF.balance;
    aHT = mF.aHT;
    mF.aHT = nullptr;
}
void CCAccount::operator=(const CCAccount & assignFrom){
    if( &assignFrom != this){
        std::cout<< "Copy Assign. from ";
        std::cout<< (long)(&assignFrom)<<" to ";
        std::cout<< (long)(this)<<"\n";
        cName=assignFrom.cName;
        balance=assignFrom.balance;
        deleteStack(aHT);
        aHT = copyStack(assignFrom.aHT);
    }
}
void CCAccount::operator=(CCAccount && moveFrom){
    if( &moveFrom != this){
        std::cout<< "Move Assign. from ";
        std::cout<< (long)(&moveFrom)<<" to ";
        std::cout<< (long)(this)<<"\n";
        cName=moveFrom.cName;
        balance=moveFrom.balance;
        deleteStack(aHT);
        aHT = moveFrom.aHT;
        moveFrom.aHT=nullptr;
    }
}

CCAccount::~CCAccount(){
    deleteStack(aHT);
    aHT=nullptr;
    std::cout<< "Destructor for "<<cName ;
    std::cout<< " address: "<<(long)(this)<<"\n";
}
CCAccount::CCAccount(){
    std::cout<< "Constructor is executed\n";
    balance=0.0;
    aHT=nullptr;
}
void CCAccount::addCharge(double x){//implementation
    aHT=push(aHT,x);
    balance += x;
}
double CCAccount::getBalance() const{ return balance;}
void CCAccount::printStatement() const{
    std::cout<< "Account owner is "<< cName<<"\n";
    std::cout<< "The balance is "<< balance<<"\n";
    SN* r=aHT;
    while(r!=nullptr){
        std::cout<< r->content<<"\t";
        r=r->aNext;
    }
    std::cout<< "\n";
}
void betterPrinting(const CCAccount& d){
    std::cout<< "This is a better way to print\n";
    d.printStatement();
}
CCAccount fWR(){// function with return
    CCAccount d;
    d.cName="Poor Chug";
    d.addCharge(15.1);d.addCharge(15.2);
    return d;
}
int main(){
    CCAccount dog;
    dog=fWR();
    dog.printStatement();
    
    return 0;
}

The topics from the videos are also covered in the lecture notes Introduction to object oriented programming.