C++ course
Lesson 3 recap
Objectives
C++ extra syntax
- Default parameter values
- Function overloading
Object Oriented
- Terminology
- Philosophy
- Programming
- Objects life cycle
- Inheritance
- Access control (public/private/protected)
- Initialisation list
Default parameter values
In C++ it is possible to provide default values to to parameters
void foo(int x = 100);
int main() {
foo(); // x will default to 100
foo(17);// x will be 17
}It is not possible to add a default to a parameter if there are more parameters without default to it's right.
void foo(int x = 100, int y); // Invalid
void foo(int x; int y = 100, int z); // Invalid
void foo(int x; int y = 1, int z = 2); // Valid
It is advisable to only add default's to the declaration(header files) the caller during compilation is supposed to only see the declarations.
Function overloading
In C++ the function signature is combined with the parameters singature
allowing to have multiple functions with the same name
int add(int a, int b)
{
return a + b;
}
double add(double a, double b)
{
return a + b;
}Notice: The functions can not differ only on the return value.
Object Oriented
OO - Terminology
// Object Oriented terminology
#include <iostream>
#include <string>
// A class is a new user defined type
// It is composed of attributes(the data) and methods(the actions that can be performed on the data)
//
// Constructor & Destructor shouldn't be considered as functions as such but rather as
// Initialization and cleanup.
class Example {
public: // Access control (Can be private/public/protected)
Example() {} // Constructor (aka ctor): has the class name and return no values
~Example() {} // Destructor (aka dtor): starts with a tilde (~) has the class name and returns no value
int attr1; // Attribute or field or member data
char* attr2;
void action1() {} // member function or method
};
int main()
{
Example e; // e is an object (or instance) of type (or class) Example
}OO - Philosophy
1. Abstraction - ability to introduce new types
2. Encapsulation
i. Object Oriented Design forces to encapsulate (pack together) related attributes and actions
ii. additional compiler directives help the compiler maintain the encapsulation (public / private / protected)
3. Inheritance - The ability to inherit and specialise behaviour
4. Polymorphism - To be discussed
class Mouse { /* ... */ }; // Introduce a new type tiger class Mouse {
private: // Enforce encapsulation by preventing the outside seeing internal implementation
int numberOfTeeth;
public:
void bite(); // A Tiger encapsulates all its actions and attributes
}; class MightyMouse : public Mouse {
/* ... */
public:
void fly();
};OO - Access modifiers
To allow the programmer to enforce encapsulation, class/struct Access modifiers were introduced.
Public: Allows access to fields and actions to everybody
class AllPublic {
public:
int field1;
void foo() { /* foo's code */ }
};
/* ... */
AllPublic ap:
ap.field1 = 1; // Access field1
ap.foo(); // Execute ap's foo method
Private: Allows access only from the class code itself
class AllPrivate {
private:
int field1;
void foo() { field1 = 10; } // Legal
};
/* ... */
AllPrivate ap:
ap.field1 = 1; // Disallowed by compiler
ap.foo(); // Disallowed by compiler
OO - Primitives
The keyword class introduced to allow creation of structs with functions (methods). Because the functions are part of the structs, the data (attributes) doesn't need to be visible from the outside.
The struct also support the new OO constructs, the difference between for backward computability is that everything is public by default for struct. While for class all is private by default.
= and =
- A struct & class compiled by a C++ compiler will have Constructor & Destructor generated for them.
- A class/struct in C++ is not obliged to have methods nor attributes. In C an empty struct is illegal.
struct A {
/* code */
} class A {
public:
/* code */
} struct A {
private:
/* code */
} class A {
/* code */
} OO - Life Cycle
C++ object model ensures that a well implemented class will have it's object always in a valid state. To enforce that each object created either on the stack or Heap, passes through a construction.
A default constructor is generated by the compiler if there was no constructor supplied by the programmer.
A Constructor is a function that returns no value and has the same name as it's class.
class Mouse {
public:
Mouse() { /* Construction code */ } // default constructor
~Mouse() { /* Destruction code */ }
};A destructor is called when the object is going out of scope or when a delete is called on an allocated object
{
Mouse m;
} // M is going out of scope, destructor called
Mouse* pMouse = new Mouse(); // Memory is allocated and than constructor is called
delete pMouse; // Destructor called and than memory is freed.
OO - Inheritance
Inheritance is allowed by publicly inheriting from a another class
public Mouse {};
public MightyMouse : public Mouse {}Inheritance allows for code reuse to be implicit from one class to the another.
This can also be viewed as specialisation, if the abstraction was done correctly, than the base class are more generic and the derived class more specific
OO - Construction sequence
Output
=>
class Value
{
public:
Value(const string& in_name): name(in_name)
{ cout << "ctor Value: (" << name << ")" << endl; }
~Value() { cout << "dtor Value: (" << name << ")" << endl; }
private:
string name;
};
class Base
{
public:
Base():baseVal("Base") { cout << "ctor Base:" << endl; }
~Base() { cout << "dtor Base:" << endl; }
private:
Value baseVal;
};
class Derived : public Base
{
public:
Derived(): derivedVal("Derived") { cout << "ctor derived: " << endl; }
~Derived() { cout << "dtor Derived:" << endl; }
private:
Value derivedVal;
};
int main() {
{
Derived d;
}
}ctor Value: (Base)
ctor Base:
ctor Value: (Derived)
ctor derived:
dtor Derived:
dtor Value: (Derived)
dtor Base:
dtor Value: (Base)OO - Constructor Initialisation list
Because as we saw in previous slide the initialisation sequence in C++, requires Base's than attributes and than self.
By the time the constructor code is reached it is expected that both Bases and attributes are already constructed.
// Excerpt from previous slide
class Base
{
public:
// Initialisation for baseVal is called before Base constructor
Base(const string& in_name = "Base"):baseVal(in_name)
{ /* code */ }
~Base() { cout << "dtor Base:" << endl; }
private:
Value baseVal;
};
class Derived : public Base
{
public:
// Initialisation of both Base and derived takes place before Derived constructor
Derived():Base("Base of Derived"), derivedVal("Derived") { cout << "ctor derived: " << endl; }
~Derived() { cout << "dtor Derived:" << endl; }
private:
Value derivedVal;
};