Date Class - Tirgul

main.cpp

#include <iostream>
#include <stdio.h>
#include "Date.h"

using namespace std;

int main() {
// defining a Data Object
    Date HerBirthDay(19,8,1976);
    printf("Her birthday is on %d / %d / %d \n",
           HerBirthDay.theDay( ) , HerBirthDay.theMonth( ),
           HerBirthDay.theYear( ) );
    HerBirthDay.advance( );
    printf("On %d / %d / %d she'll be very happy\n",
           HerBirthDay.theDay( ) , HerBirthDay.theMonth( ),
           HerBirthDay.theYear( ) );
// HerBirthDay.day_ ++ ; // illegal: day_ is private
// HerBirthDay.month_=8;// illegal: month_ is private
    return 0;
}

Date.h

Date.cpp

Function Prototype- הצהרה

We can see the our Date.h only contains prototypes of our class.

Const member function

int theDay() const;
int theMonth() const;
int theYear() const;

Here we also notice that the functions above end with const. const ensures us that the functions will not change the object but rather read only its values

Implementing our Class

int Date::theDay() const {
   return day_;
}

In Date.cpp we implemented our member funtion.

We use the :: or scope resolution operator to Define funtions in our class.

Constuctors

1. doesnt return (not even void)

2. its name is similar to classes

3. better to initinize with init lists

Date::Date(int day, int month, int year) :
       day_(day), month_(month), year_(year) { }

Public & Private

class Date{
private:
   int day_;
public:
   int theDay() const;

theDay() is public which mean anyone can call and access it. While day_ is private which means only our class can access (or call when needed). Friend classes/methods can also access or call or private member functions or variables.

Member variables are almost always private

Overloading

If if were to replace our main with the following would the code compile?

int main() {
    Date yesterday;
    Date array_of_dates[100];
    return 0;
}

NO!!! We don't have a default constructor. We overloaded it.

Lets add a default ctor

main.cpp

int main() {
    Date hisBirthDay(19,8,1996); // calls 3 arg ctor
    Date yesterday; // calls param-less ctor
    Date array_of_dates[100]; // calls param-less ctor 100 times
    return 0;
}

Date.h

Date.cpp

The compiler knows which to ctor to call by the number of arguments in the parameter and their types.

Watch out from this!

The following is incorrect

int main() {
    Date someday(); 
    return 0;
}

The compiler believes this is a declaration of a function who returns a Date.

Overloading our advance funcion

TABS

Date.h

main.cpp

int main() {
    Date hisBirthDay(19,8,1996);
    hisBirthDay.advance(3); //22-8-96
    hisBirthDay.advance();
    return 0;
}

Date.h

Date.cpp

Default args

We can change

class Date{
public:
  Date(int,int,int);

to this

class Date{
public:
  Date(int day=31,int month=12,int year=2000);

We can only give default args to the end of our functions/ctors so the following is incorrect:

class Date{
public:
  Date(int day=31,int month=12,int year);

Const

int main() {
  const Date newYear99(1,1,1999);
  Date someday;

  newYear99 = someday; // illegal. newYear is const.
  newYear99.advance(); // illegal. advance is non-const func.
  newYear99.theDay(); // ok. theDay is a const func.

  someday = Date(21,4,98); // ok
  someday.advance(); // ok
  someday = newYear99; // ok. A non-const copy is created
}

newYear99.advance() can't be called because

class Date{
public:
  void advance();
  int theDay() const;

isn't a const function but newYear99.theDay() may be called for it is a const function.

Pointer to a const

int main(){
  const Date constDate(1,1,1999);
  Date normDate;
  const Date* constPointer;
  Date* normPointer;

  normPointer = &normDate; //ok
  constPointer = &normDate; //ok
  normPointer->advance(); //ok
  //constPointer->advance(); //illegal – even if we're actually
  //not pointing at const

  constPointer->theDay(); //ok

  //normPointer = &constDate; //illegal!
  constPointer = &constDate; //ok
  constPointer->theDay(); //ok
}

A pointer to a const can change itself to another address to the following is legal:

constPointer = &normDate;
constPointer = &constDate;

But it can't change the value to what it points to so this is illegal

constPointer->advance();

const const

int main(){
  Date* const cpoint = new Date(1,1,1999); //the address is const
  const Date* const ccpoint = new Date(1,1,1998);
//address and value are const
  cpoint->advance(); //ok
  ccpoint->advance(); //illegal
}

Here cpoint address can't be changed but the values can. While ccpoint can't change either

Const and functions

void printDate(Date d);
void printDateP(Date* d);
void printDatePConst(const Date* d);

printDate(normDate); //ok
printDate(constDate); //On good compilers - ALSO OK!!!!
printDateP(&normDate); //ok
printDatePConst(&normDate); //ok. Remember - const pointer can point to non-const
printDatePConst(&constDate); //ok

The following case is illegal

printDateP(&constDate); //Illegal!

Return values from functions

const int * Date::getYearPointer() {
  return &_year;

Here the returned pointer is const, though the original field wasn't. The following is legal:

const int * pc = normDate.getYearPointer(); //ok

Here the following is illegal

int * p = normDate.getYearPointer(); //illegal – function returns const pointer!
*pc=3 //illegal! pc is a const pointer!