Template Class

أنشِئ Class :

اسمه: Addition

المتغيرات : elem1 ,elem2

يحوي : parameterized constructor و دالة لحساب مجموع العنصرين  و دالة لطباعة محتوى  .

-أجعل هذا الـ class يستقبل أي نوع من البيانات ، بمعنى يمكنه جمع أي عددين سواءً int أو double أو أي نوع آخر .

الحل:

جعل الـ class يستقبل أي نوع من البيانات يعني استخدام مفهوم template .

//main.cpp
#include <iostream>
using namespace std;
#include <string>

template <typename T>
class Addition
{

 T elem1;
 T elem2;

public:

 Addition(T val1, T val2);
 T calc();
 void print();

};


template <typename T> Addition<T>::Addition(T val1, T val2)
{
 elem1 = val1;
 elem2 = val2;
}

template <typename T> T Addition<T>::calc()
{
 return elem1 + elem2;
}

template <typename T> void Addition<T>::print()
{
 cout << "Result is: " << calc() << endl;

}

void main()
{
 Addition<int> ADD1st(9, 8);

 cout << "int type| ";
 ADD1st.print();

 Addition<double> ADD2nd(1.2 , 6.2);
 cout << "double type| ";
 ADD2nd.print();

 Addition<string> ADD3rd("HE", "llo");
 cout << "string type| ";
 ADD3rd.print();

 system("pause");
}

 

Operator Overloading

أنشِئ Class :

اسمهFraction

المتغيرات numerator , denominator

يحوي : default constructor و  set & get و  overloading functions للعمليات التالية :

جمع ، أقل من ، ضرب >> as global functions .

قسمة ، إسناد “=”  >> as member functions .

قراءة وطباعة .

-في main قم باختبار كل الـ operator overloading functions .

الحل:

مفهوم operator overloading هو أن نعيد تعريف الـ built-in operator حتى نتمكن من تطبيقها على الـ objects كأن نجمع 2 objects أو نضربهما ..الخ .

نلاحظ في السؤال أنه لم يتم التوضيح بالنسة لعملية القراءة cin والطباعة cout ماإذا كانت member or global لأنها في الواقع لايمكن ان تكون سوى global أي friend .

-يجب أن نراعي في الحل قوانين ضرب وجمع وقسمة ومقارنة الكسور .

 

//.h
#include <iostream>
using namespace std;

class Fraction
{
private:
 int numerator;
 int denominator;

public:
 Fraction(){ numerator = 0; denominator = 0; }

 void setNumerator(int num)
 {
 numerator = num;
 }
 void setDenominator(int num)
 {
 denominator = num;
 }
 int getNumerator()
 {
 return numerator;
 }
 int getDenominator()
 {
 return denominator;
 }

 //global means (friend) "optional"
 friend Fraction operator +(Fraction &obj1, Fraction &obj2);
 friend bool operator < (Fraction &obj1, Fraction &obj2);
 friend Fraction operator *(Fraction &obj1, Fraction &obj2);

 //member function "optional"
 void operator = (Fraction &obj);
 Fraction operator /(Fraction &obj);

 //must be friend
 friend ostream& operator << (ostream& outs, const Fraction& ob);
 friend istream& operator>>(istream& inc, Fraction& ob);

};
-----------------------------------------------------------
//.cpp
#include "Fraction.h"
#include <iostream>
using namespace std;

Fraction operator +(Fraction &obj1, Fraction &obj2)
{
 Fraction obj3;
 obj3.denominator = obj1.denominator * obj2.denominator;
 obj3.numerator = (obj1.numerator*obj2.denominator) + (obj2.numerator*obj1.denominator);
 return obj3;
}

bool operator < (Fraction &obj1, Fraction &obj2)
{
 if ((obj1.numerator / obj1.denominator) < (obj2.numerator / obj2.denominator))

 return true;

 else return false;
}

Fraction operator *(Fraction &obj1, Fraction &obj2)
{
 Fraction obj3;
 obj3.denominator = obj1.denominator*obj2.denominator;
 obj3.numerator = obj1.numerator*obj2.numerator;
 return obj3;
}

void Fraction::operator = (Fraction &obj)
{
 numerator = obj.numerator;
 denominator = obj.denominator;
}

Fraction Fraction::operator/(Fraction &obj)
{
 Fraction obj3;
 obj3.denominator = denominator*obj.numerator;
 obj3.numerator = numerator*obj.denominator;
 return obj3;
}

ostream& operator << (ostream& outs, const Fraction& ob)
{
 outs << "The result is: ";
 outs << ob.numerator << "/" << ob.denominator << endl;
 return outs;
}

istream& operator >> (istream& inc, Fraction& ob)
{
 cout << "Enter the number numerator: ";
 inc >> ob.numerator;
 cout << "Enter the number denominator: ";
 inc >> ob.denominator;
 return inc;
}
---------------------------------------------------
//main.cpp
#include <iostream>
using namespace std;
#include "Fraction.h"
int main() {

 Fraction f1, f2;

 cin >> f1;
 cin >> f2;

 cout << " << operator:\n";
 cout << f1 << f2;

 cout << " + operator: ";
 Fraction f3 = (f1 + f2);
 cout << f3;

 cout << " < operator: ";
 cout << (f1<f2) << endl;

 cout << " * operator: ";
 Fraction f4 = f1*f2;
 cout << f4;

 cout << " = operator: ";
 Fraction f5 = f1;
 cout << f5;

 cout << " / operator: ";
 cout << (f1 / f2);



 system("pause");
 return 0;
}

Polymorphism

أنشِئ Class :

اسمه: novel

المتغيرات : ntype, nprice

يحوي : دالة تقوم بعمل return لسعر الرواية وهو 30 بشكل عام ، ودالة تقوم بعمل return لنوع الرواية وهو general ودالة لطباعة المعلومات .

هذا الـ Class  هو Base Class  ، والتالية هي  Derived Classes  : “مفهوم الوراثة

الـ  Classes التالية لديها مثل متغيرات الـ Class الأب ، ولكن تعريفات(وليست أسماء) أخرى للدوال عن تلك الموجودة في الـ class الأب !

الـ Class الأول  :

اسمه: Agatha

يحوي : يختلف بأن سعر الرواية هو 15 ونوعها mystery .

الـ Class الثاني:

اسمه: McGraw

 يحوي : تختلف فقط في سعر الرواية هو 20 أما النوع لايختلف عن النوع العام general .

الـ Class الثالث:

اسمه: Signed

 يحوي : تختلف فقط في نوع الرواية هو signed أما السعر لايختلف عن السعر العام 30.

أكتب هذه الـ Classes بحيث في main عندما تُنشِئ pointer من نوع novel  وتجعله يشير لأنواع مختلفة من الـ objects يعرض معلومات صحيحة لكل نوع ، بمعنى عندما تجعله يشير للـ object من نوع Signed وتقوم بتعبئة معلوماته عن طريق الدوال ثم تطبع المعلومات نجد أن النوع ليس general وإنما signed.  “مفهوم الـ polymorphism”

الحل:

#include <iostream>
#include <string>
using namespace std;

class novel
{
public:
 double nprice;
 string ntype;

 virtual double price(){ return 30; }
 virtual string type(){ return "general"; }

 void display()
 {
 cout << "Novel price= " << nprice << endl;
 cout << "Novel type= " << ntype << endl;
 }
};
//-----------------------------------------------------//
class Agatha :public novel
{
public:
 double price(){ return 15; }
 string type(){ return "mystery"; }
};
//----------------------------------------------------//
class McGraw :public novel
{
public:
 double price(){ return 20; }
};
//----------------------------------------------------//
class Signed :public novel
{
public: string type(){ return "signed"; }
};
//----------------------------------------------------//
void main()
{
 Agatha a;
 McGraw m;
 Signed s;
 novel *n;

 n = &a;
 //fill info
 n->nprice = n->price();
 n->ntype = n->type();
 //print
 n->display();

 n = &m;
 n->nprice = n->price();
 n->ntype = n->type();
 n->display();

 n = &s;
 n->nprice = n->price();
 n->ntype = n->type();
 n->display();

 system("pause");
}

السطر 11 و 12 : كلمة virtual هي التي تسمح لي بإعطاء تعريفات اخرى للدوال في الـ classes الأخرى 

Inheritance الوراثة

أنشِئ Class :

اسمه: publication

المتغيرات : title , price

يحوي :  Parameterized constructor  و  default constructor و دالة تقرأ من المستخدم  البيانات للمتغيرات  وتخزنها و أخيرًا دالة طباعة.

هذا الـ Class  هو Base Class  ، والتالية هي  Derived Classes  : “مفهوم الوراثة “

الـ Class الأول  :

اسمه: Book 

المتغيرات : Pagecount

يحوي :  Parameterized constructor يقوم بعمل initialize لـ Data Member متضمنة الـ Data Member للـ Base Class  و دالة تقرأ من المستخدم  البيانات للمتغيرات وتخزنها و أخيرًا دالة طباعة.

 

الـ Class الثاني :

اسمه: Tape

المتغيرات : PlayingTinM “Playing Time in minute” .

يحوي :  Parameterized constructor يقوم بعمل initialize لـ Data Member متضمنة الـ Data Member للـ Base Class  و دالة تقرأ من المستخدم  البيانات للمتغيرات وتخزنها و أخيرًا دالة طباعة.

-قم بفصل الـ Class interface  في header file و Class implementation في cpp file

الحل: 

//publication.h

#include <iostream>
#include <string>
using namespace std;

#ifndef CLASS_PUBLICATION
#define CLASS_PUBLICATION

class publication
{
private:
 string title;
 float price;
public:

 publication();
 publication(string t, float p);
 void getdata();
 void putdata() const;
};

#endif
--------------------------------------------------
//publication.cpp
#include <iostream>
#include <string>
#include "publication.h"
using namespace std;

publication::publication(){ title = ""; price = 0; }
publication::publication(string t, float p){ title = t; price = p; }

void publication::getdata()
{
 cout << "Enter title:"; cin >> title;
 cout << "Enter price: "; cin >> price;
}
void publication::putdata() const
{
 cout << "\nTitle: " << title;
 cout << "\nPrice: " << price << endl;
}
-----------------------------------------------
//book.h
#include <iostream>
#include <string>
#include "publication.h"
using namespace std;


class Book :public publication
{
 int PageCount;
public:
 Book(int, float, string);
 void getdata();
 void putdata()const;

};
----------------------------------
//book.cpp
#include <iostream>
#include <string>
#include "publication.h"
#include "Book.h"
using namespace std;


Book::Book(int Pg, float Price, string T) :PageCount(Pg), publication(T, Price){}
void Book::getdata()
{
 publication::getdata();
 cout << "Enter the Page number: "; cin >> PageCount;
}
void Book::putdata()const
{
 cout << "Page Count: " << PageCount << endl << endl;
}
------------------------------------
//tape.h
#include <iostream>
#include <string>
#include "publication.h"
using namespace std;


class Tape : public publication
{
 float PlayingTinM;
public:
 Tape(float, float, string);
 void getdata();
 void putdata()const;
};
----------------------------------------
//tape.cpp
#include <iostream>
#include <string>
#include "publication.h"
#include "Tape.h"
using namespace std;

Tape::Tape(float PTIM, float Price, string T) :PlayingTinM(PTIM), publication(T, Price){}

void Tape::getdata()
{
 publication::getdata();
 cout << "Enter the Playing Time in miunte: "; cin >> PlayingTinM;
}
void Tape::putdata()const
{
 cout << "the Playing Time in miunte: " << PlayingTinM << endl;
}

 

السطر 7 و 8 و 23 : هذا الـ Directive هو حل لهذا الخطأ

 Error 1 error C2011: ‘publication’ : ‘class’ type redefinition c:\users\amjad\documents\visual studio 2013\projects\myblog\myblog\publication.h 7 1 myBlog

السطر 52 و 88 : طريقة الوراثة بكتابة نوع الوراثة ثم اسم الـ Base Class

السطر 70  و 104 : طريقة عمل initialize لمتغيرات الـ Base Class عن طريق مناداة الـ Constructor للـ Base Class

Cascading

أنشِئ Class :

اسمه: MyAge

المتغيرات : Year , Month , Day

يحوي :  Set functions و Print Function  و  default constructor.

* يجب أن تُكتب الـ functions حتى نستطيع أن نقوم بعمل Cascading Call في Main functions .

-قم بفصل الـ Class interface  في header file و Class implementation في cpp file

الحل:

طريقة كتابة الـ function حتى نستطيع القيام بعمل Cascading Call هي أن

  1. يكون الـ return type لها هو object من نفس نوع الـ Class بهذه الطريقة  ( & ClassName  ) .

  2. أن تكون الـ return value هي pointer للـ object الذي قام باستدعاء هذه الـ function وهو *this .

//.h
#include <iostream>
using namespace std; 

class MyAge
{
public:
 MyAge();
 MyAge &My_yers(int);
 MyAge &My_month(int);
 MyAge &My_day(int);
 void print();


private:
 int year;
 int month;
 int day;

};
------------------------------------------------------
//.cpp
#include <iostream>
#include "MyAge.h"
using namespace std;

MyAge::MyAge(){ year = 0; month = 0; day = 0; } //default constructor

MyAge & MyAge::My_yers(int y)
{
 year = y; //initialize years
 return *this; //return value
}

MyAge & MyAge::My_month(int m)
{
 month = m; //initialize month
 return *this; //return value
}

MyAge & MyAge::My_day(int d)
{
 day = d; //initialize day
 return *this; //return value
}

void MyAge::print()
{
 cout << year << "/" << month << "/" << day << endl; /*ptint out years and months */
}
-----------------------------------------------
//main
#include <iostream>
#include "MyAge.h"
using namespace std;

void main()
{
 MyAge age;

 age.My_yers(2000).My_month(1).My_day(20).print(); //Cascading Call

 system("pause");

}


Composition & Friend Class & Pointer to object

أنشِئ Class :

اسمه: Job

المتغيرات : role , salary , id .

 

أنشِئ Class :

اسمه: Person

المتغيرات : Job  object  وهي عبارة عن”Composition “has-a relationship.

يحوي : Print Salary function تقوم بطباعة الراتب بدون get function .

-أجعل Person Class friend لـ Job class .

في main function :

* أنشِئ  Job & Person وأطبع الـ Salary باستخدام Person Object .

-أكتب ترتيب مناداة الـ Destructors للـ objects بمعنى آخر أي الـ objects تم تدميره أولًا .

-قم بفصل الـ Class interface  في header file و Class implementation في cpp file

الحل:

//Job.h
#include <iostream>
#include <string>
using namespace std;
class Job
{
private:
 string role;
 float salary;
 int id;

public:
 Job();
 ~Job();//destructor 

 string getRole()const;
 void setRole(string Role);

 float getSalary()const;
 void setSalary(float Salary);

 int getId()const;
 void setId(int ID);

 friend class Person; //friend class
};
------------------------------------------------
//Job.cpp
#include "Job.h"

Job::Job(){ role = " "; salary = 0; id = 0; }
Job::~Job(){ cout << "Job has been destructed\n\n"; } //destructor 

string Job::getRole()const { return role; }
void Job::setRole(string Role){ role = Role; }

float Job::getSalary()const{ return salary;}
void Job::setSalary(float Salary) { salary = Salary; }

int Job::getId()const{ return id; }
void Job::setId(int ID) { id = ID; }
-----------------------------------------------
//Person.h
#include "Job.h" //Must Include
class Person {

private:
 Job job; //composition has-a relationship


public:
 Person(const Job& myjob); //Copy Constructor 
 ~Person(); //destructor 
 void printSalary();
};

--------------------------------------------------
//Person.cpp
#include "Person.h"

Person::Person(const Job & myjob)
{
 job.salary = myjob.salary; 
 job.id = myjob.id;
 job.role = myjob.role;
}

Person::~Person(){ cout << "\nPerson has been destructed\n"; }//destructor 

void Person::printSalary()
{
 //Person can access a private data member of job class because it's friend

 cout << "The Salary is: " <<job.salary <<endl;
}
---------------------------------------------
//Main.cpp
#include <iostream>
#include <string>
#include "Person.h"

using namespace std;

void main()
{
 Job job;

 job.setRole("maneger");
 job.setId(4333200);
 job.setSalary(30000);

 Person *person = new Person(job); //Pointer to Person object

 person->printSalary();

 delete person; //to trace the destructor operation 

 system("pause");
}

السطر 25 : طريقة الـ class friend .

السطر 48 : Object Data Member .

السطر 74 : يستطيع Person الوصول للـ Private Data Memeber لـ Job لأنه Friend بدون الحاجة للـ Get Function .

السطر 92  : طريقة إنشاء Pointer to object .

السطر 94 : طريقة مناداة الـ pointer للـ function عن طريق Arrow “->” بدل “.” 

Statcic and Const data member and Const function

أنشِئ Class :

اسمه: Patient

المتغيرات : Name , Age , ID , DoctorName

:يحوي  Parameterized constructor و Display function “لطباعة معلومات كل مريض “.

-Get function , Display function يجب أن تكون read only .

-ID الخاص بكل مريض يتم إنشاؤه أوتوماتكيًا ولايمكن تغييره .

–قم بفصل الـ Class interface  في header file و Class implementation في cpp file

*في Main function أنشِئ 3 objects وأطبع معلوماتهم.

الحل:

المقصود بـ read only هي أن تكون constant function وهذا النوع من الـ functions لايمكنه تغيير قيمة أي متغير ، مثال لايمكن كتابة هذه الجملة داخل هذا النوع من الدوال : Name = “Amjad” >> “Error.

إنشاء الـ ID أتوماتيكيًا يتم عن طريق تعريف static data member بحيث أن static هو متغيّر عام تشترك فيه كل objects لهذا الـ class وليس خاص لكل object ، بحيث أن كل تغيير على static تستطيع أن تراه كل الـ objects .

-ID يكون const حتى لايتم تغييره ، وبذلك لايحتاج إلى set function لأنه لايمكن التعديل عليه .

//.h
#include <iostream>
#include <string>
using namespace std;

class patient
{
 string Name;
 float age;
 const int ID; //const ID
 string doctorName;
 static int num; // stataic var. to generate the ID automatically
public:

 patient(string, string, float); //Parameterized constructor 

//set functions 
 void SetName(string);
 void SetdoctorName(string);
 void Setage(float);

//read only get functions
 string GetName() const;
 string GetdoctorName() const;
 float Getage() const;
 int GetID() const;

//const display function
 void Display() const;
};
-----------------------------------------------------------------
//.cpp
#include <iostream>
#include <string>
#include "patient.h"
using namespace std;

int patient::num = 0; //initialize static data memebr

////Parameterized constructor 
//initialize the data members using initializer list
patient::patient(string N, string DN, float A) :Name(N), doctorName(DN), age(A), ID(++num){}//initialize ID by num

//set functions
void patient::SetName(string N){ Name = N; }
void patient::Setage(float A){ age = A; }
void patient::SetdoctorName(string DN){ doctorName = DN; }

//const get functions
string patient::GetName() const{ return Name; }
string patient::GetdoctorName() const { return doctorName; }
float patient::Getage() const{ return age; }
int patient::GetID() const { return ID; }


//const display function
void patient::Display() const
{
 
 cout << "Your ID: " << GetID() << endl;
 cout << "Your Name: " << GetName() << endl;
 cout << "YOur Age: " << Getage() << endl;
 cout << "Your D. Name: " << GetdoctorName() << endl << endl;
}
------------------------------------------------------------
//main.cpp
#include <iostream>
#include <string>
#include "patient.h"
using namespace std;


void main()
{
 string Name[3], doctorName[3]; float age[3];

//read the info
 for (int i = 0; i<3; i++)

 {
 cout << "you are patint #" << i + 1 << endl;
 cout << "Enter Your Name: ";
 cin >> Name[i];
 cout << "Enter YOur Age: ";
 cin >> age[i];
 cout << "Enter Your D. Name: ";
 cin >> doctorName[i];
 cout << endl;
 }

//create objects
 patient obj1(Name[0], doctorName[0], age[0]);
 patient obj2(Name[1], doctorName[1], age[1]);
 patient obj3(Name[2], doctorName[2], age[2]);

//print info
 obj1.Display();
 obj2.Display();
 obj3.Display();

 system("pause");

}




-السطر 38 طريقة تعريف static  في cpp.

-السطر 42 يحوي طريقة initialize ID باستخدام static data member.