#include
using namespace std;

int main()
{
    double first, second, sum;
    cin >> first >> second;
    sum = first + second;
    cout << sum << endl;
}

#include<iostream>
using namespace std;

class Calculator
{
public:
    double add(double first, double second);
    void display(double sum);
    void takeInput();
};

double g_first, g_second;
int main()
{
   double sum;
   Calculator myCalculator;
   myCalculator.takeInput();
   sum = myCalculator.add(g_first, g_second);
   myCalculator.display(sum);
}

double Calculator::add(double first, double second)
{
   double sum = 0;
   sum = first + second;
   return sum;
}

void Calculator::display(double sum)
{
  cout << sum << endl;
}

void Calculator::takeInput()
{
   g_first = g_second = 0;
   cin >> g_first >> g_second;
}

#include

using namespace std;

enum EmployeeTypes
{
   Manager,
   Officer,
   Clerk
};

class SalaryCalculator
{
public:
   double getSalary(EmployeeTypes type);
};

double SalaryCalculator::getSalary(EmployeeTypes types)
{
  switch (types)
  {
    case Manager:
        return 100000;
    case Officer:
        return 50000;
    case Clerk:
        return 20000;
    default:
        return 0;
  }
}

1. Put taxes for the employees who withdraw salary more than 50000/=
2. Want to introduce Human Resource Manager into office who will get 35000/= per month.

1. Add another enum type
2. Add another check in the switch
3. Add logic to check whether the salary is more than 50000/= or not etc..

1. This may cost in functionality malfunctioning.
2. Class is getting bigger and various type of code smell will arises.
3. Maintenance of the code will be getting harder followed by requirement changes.
4. Unit test case may fail for those random changes.

• Tax rule
• Introduction of new employee
• Change of salary amount
• Change of salary calculation logic

• Decouple the responsibility of this class
• Introduce inheritance and interface if needed
• Use dynamic polymorphism etc..
• Use abstraction

1. Now declare an abstract class for Employee

class Empolyee
{
 public:
   virtual double getSalary();
};

class Officer : Empolyee
{
 public:
   double getSalary()
   {
      return 50000;
   }
};

class Manager : Empolyee
{
 public :
    double getSalary()
    {
       return 100000;
    }
};

class Clerk : Empolyee
{
 public:
  double getSalary()
  {
    return 20000;
  }
};

void display(double salary)
{
  cout << salary << endl;
}

int main()
{
  SalaryCalculator mySalaryCalculator;
  Manager myManager;
  Officer myOfficer;
  Clerk myClerk;

  display ( mySalaryCalculator.getSalary( myManager ) );
  display ( mySalaryCalculator.getSalary( myOfficer ) );
  display ( mySalaryCalculator.getSalary( myClerk ) );
}

• Put 1% tax is applied for the salary more than 50000/=.

• Introduced Human Resource Manager having salary 35000/=

class Animal
{
public:
  virtual void Eat();
  virtual void Drink();
  virtual void Run();
  virtual void Fly();
};

class Animal
{
 public:
   void Eat();
   void Drink();
};

void Animal::Eat()
{
  cout << "Can eat" << endl;
}

void Animal::Drink()
{
  cout << "Can drink" << endl;
}

 __interface IRunnable
{
 public:
   void Run();
};

 __interface IFlyable
{
 public:
    void Fly();
};

class Lion : public Animal, public IRunnable
{
 public:
   void Eat();
   void Drink();
   void Run();
};

void Lion::Eat()
{
  cout << "Eat flesh" << endl;
}

void Lion::Drink()
{
  cout << "Drink water" << endl;
}

void Lion::Run()
{
  cout << "Runs fast" << endl;
}

class Eagle : public Animal, public IFlyable
{
 public:
   void Eat();
   void Drink();
   void Fly();
};

void Eagle::Eat()
{
  cout << "Eat flesh" << endl;
}

void Eagle::Drink()
{
  cout << "Drinks water" << endl;
}

void Eagle::Fly()
{
  cout << "Fly high" << endl;
}

__interface ISmartDevice
{
  void Print();
  void Fax();
  void Scan();
};

class AllInOnePrinter : public ISmartDevice
{
 public:
   void Print();    
   void Fax();
   void Scan();
};

void AllInOnePrinter::Print()
{
   cout << "Printing code." << endl;
}

void AllInOnePrinter::Fax()
{
  cout << "Beep booop biiiiip." << endl;
}

void AllInOnePrinter::Scan()
{
  cout << "Scanning code." << endl;
}

class EconomicPrinter : public ISmartDevice
{
 public:
   void Print();
   void Fax();
   void Scan();
};

void EconomicPrinter::Print() 
{
  cout << "Yes I can print." << endl;
}

void EconomicPrinter::Fax()
{
  throw new exception;
}

void EconomicPrinter::Scan()
{
  throw new exception();
}

__interface IPrinter 
{
   void Print();
};

__interface IFax 
{
   void Fax();
};

__interface IScanner 
{
   void Scan();
};

class EconomicPrinter :public IPrinter
{
 public:
   void Print();
};

void EconomicPrinter::Print() 
{
   cout << "Yes I can print." << endl;
}

class AllInOnePrinter :public IPrinter,public IFax,public IScanner
{
 public:
   void Print();    
   void Fax();
   void Scan();
};

void AllInOnePrinter::Print()
{
  cout << "Printing code." << endl;
}

void AllInOnePrinter::Fax()
{
  cout << "Beep booop biiiiip." << endl;
}

void AllInOnePrinter::Scan()
{
   cout << "Scanning code." << endl;
}

class Worker
{
 public:
   void doWork();
};

void Worker::doWork()
{
  cout << "working..." << endl;
}


class Manager
{
 public:
   Worker worker;

   void setWork(Worker w);
   void manageWorker();     
};

void Manager::setWork(Worker worker)
{
   this->worker = worker;
}

void Manager::manageWorker()
{
   worker.doWork();
}

• We have to change the Manager class
• Some of the current functionality from the Manager class might be affected.
• Unit test case may fail or should be redone.

class SuperWorker
{
 public:
   void doWork();
};

void SuperWorker::doWork()
{
   cout << "Working much more" << endl;
}


class Manager
{
public:
  Worker worker;
  SuperWorker superWorker;

  void setWork(Worker w);
  void setWork(SuperWorker w);

  void manageWorker();
  void manageSupperWorker();        
};

void Manager::setWork(Worker worker)
{
   this->worker = worker;
}
void Manager::setWork(SuperWorker superWorker)
{
   this->superWorker = superWorker;
}

void Manager::manageWorker()
{
   worker.doWork();
}
void Manager::manageSupperWorker()
{
   superWorker.doWork();
}

•  Lower classes will implement this Interface.

class Worker: public IWorker
{
 public:
   void doWork();
};

void Worker::doWork()
{
   cout << "working..." << endl;
}

class SuperWorker: public IWorker
{
 public:
    void doWork();
};

void SuperWorker::doWork()
{
   cout << "Working much more" << endl;
}

class Manager
{
 public:
   IWorker *worker;

   void setWork(IWorker *worker);
   void manageWorker();
};

void Manager::setWork(IWorker *worker)
{
   this->worker = worker;
}

void Manager::manageWorker()
{
   worker->doWork();
}