Lecture 9

Class

• Big innovation in OOP

• Can put functions inside a struct

Example:

// file: student.h

#ifndef STUDENT_H
#define STUDENT_H

struct student {
  int assns, mt, final;
  float grade(); // forward declaration
};

// file: student.cc

#include "student.h"
float Student::grade() { // veru similar to std::
return this->assns*0.5+this->mt*0.2+this->final*0.4;
}

Student billy {70, 50, 75};
Student billy = {70, 50, 75};
billy.grade();

Class: A struct that contains functions

• every C++ struct can contain functions

• An instance/value of a class is called an object

  • I.e. Billy is an object

Member: Function within a class

• eg. grade(); //invalid

• Must use object to call a method

• methods are called on objects

• Within method call, method has access fields of the object

Methods

• have hidden parameter

  • "this"

  • "this" points to object used to call method eg.

this == &billy => (*this == billy)
this->assns == (*this).assns

Style Initialization:

student billy {70,50,75};

• requires "parameters" to be compile time constant

• C++ allows special methods called constructors to construct objects

Example:

// file: student.h

struct Student {
  int assns, my, final;
  ...
  Student(int assns, int mt, int final); // constructor - same name as class
};

// file: student.cc

Student::student(int assns, int mt, int final);
this->assns=assns;
this->mt=mt;
this->final=final;

Compare:

// Initializing using constructor
// constructor has 3 ints in parameters, so this works
Student billy {70,50,75}; // goes to c-style intialization if no constructor


// Initializing without constructor
// if constructor does not take any arguments, then you would do this
Student billy = {70,70,75};

// Putting "billy" on the heap, not the stack

Student *pbilly = new Student {70, 50, 75};
delete pbilly;

Advantages of Constructors:

• args do not need to be constants

• method overloading (different parameters)

• ctor body can execute any code

  • ex. sanity checks

• default args

Example:

// file: student.h

struct Student {
  Student(int assns=0, int mt=0, int final=0); // default value in header file only
}

// file: student.cc
Student::Student(int assns, int mt, int final) {
this->assns = assns < 0? 0:assns;
this->mt = mt < 0? 0:mt;
this->final = final < 0? 0:final;
}

Student s2 {80, 60}; // final=0
Student s3 {75}; // mt=final=0
Student s4 {}; // mt=final=assns=0
Student s4;

int main() {
  // requires a 3 parameter constructor
  // (only available when program is running, cannot do c-style intialization => not constants)
  int x,y,z;
  cin >> x >> y >> z;
  Student s {x, y, z};
}

Default Constructor

Every class comes with a default ctor

• ctor with 0 parameters

• calls default ctors on fields that are objects Example

struct MyStruct {
  int x;  // calls default ctor
  Student y;  // x, p will not be initialized
  Vec *p; // y has been initialized
};

• ctor body -> too late to initialize constant

• Hijack step 2 to intialize constants/references

• MIL: Members Initialization List