Question

solve it in c++10

Create a composition between the classes Job and Salary.

Class Salary

a. data member:
   1. money
b. constructors:
   1. default constructor
   2. user defined constructor with a parameter to set money
c. standard accessor and mutator functions

Class Job

a. data members:
   title (name of the job)
   salary (object of type Salary)

b. constructors:
   1. default constructor
   2. user defined constructor to set title and salary
   3. implement constructor delegation

c. standard accessor and mutator function for title
d. accessor function to read the money value of the internal Salary object
e. mutator function to update the money value of the internal Salary object
f. accessor function to return a copy of the internal Salary object
g. mutator function to replace the internal Salary object

Main

** question 1

. Instantiate a Job object and print it to screen (match output below)

Example Output

Programmer 100000

****question 2

Overload the << operator for the Job class:
Assume that this operator is not overloaded for the Salary class.

a) Write how the function will be declared in your code.
b) Write an external function definition (not inside the class).

****question 3

Overload the >> operator for the Salary class:

a) Write how the function will be declared in your code.
b) Write an external function definition (not inside the class).

**** question 4

Overload a relational operator for the Job class:
Assume that this operator is not overloaded for the Salary class.

a) Write how the function will be declared in your code.
b) Write an external function definition (not inside the class).

quesion 5

Overload an arithmetic operator for the Salary class which supports automatic type conversion:

a) Write how the function will be declared in your code.
b) Write an external function definition (not inside the class).

**** question 6

Overload a relational operator for Job to determine which job is better (makes more money):

a) Write how the function will be declared in your code.
b) Write an external function definition (not inside the class).

Answer 1

Program:

#include<iostream>

using namespace std;

//Salary class
class Salary
{
private:
//private member
double money;
public:
//default constructor
Salary(){money = 0;}
//parameterized constructor
Salary(double money){this->money = money;}
//accessor function
double getMoney(){ return money;}
//mutator function
void setMoney(double money){this->money = money;}
//declaration of >> operator overloading
friend istream& operator>>(istream &is, Salary &salary);
//arithmetic operator overloading for type conversion:
operator double();
};

//definition of >> operator overloading
istream& operator>>(istream &is, Salary &salary)
{
is>>salary.money;
return is;
}

//arithmetic operator overloading for type conversion:
Salary::operator double()
{
return this->money;
}

//Job class
class Job
{
private:
//private members
string title;
Salary salary;
public:
//default constructor
Job()
{
title = "";
salary = 0;
}
//parameterized constructor
Job(string jobname)
{
title = jobname;
}
//parameterized constructor
Job(string jobname, Salary sal): Job(jobname)
{
salary = sal;
}
//accessor function for title
string getTitle(){ return title;}
//mutator function for title
void setTitle(string jobname){title = jobname;}
//accessor function for the internal Salary object
Salary getSalary() {return salary;}
//mutator function for the internal Salary object
void setSalary(Salary sal){salary = sal;}
//accessor function for the money value
double getMoneyValue() {return salary.getMoney();}
//mutator function for the the money value
void setMoneyValue(double money){salary = Salary(money);}
//declaration of << operator overloading
friend ostream& operator<<(ostream &os, Job &job);
//declaration of relational operator == overloading
bool operator==(Job &job);
//declaration of relational operator > overloading
bool operator>(Job &job);

};

//definition of << operator overloading
ostream& operator<<(ostream &os, Job &job)
{
os<<job.title<<" ";
os<<job.getMoneyValue();
return os;
}

//definition of relational operator overloading
bool Job::operator==(Job &job)
{
return this->getMoneyValue()==job.getMoneyValue();
}

//definition of relational operator > overloading
bool Job::operator>(Job &job)
{
return this->getMoneyValue() > job.getMoneyValue();
}

//main function
int main()
{
//Instantiate a Job object
Job job("Programmer", 100000);

//print it to screen
cout<<job;

return 0;
}

Output:

Programmer 100000