《Introduction to Programming with C++》读书笔记

💡 本文档记录了笔者2022年暑假啃《Introduction to Programming with C++》这本书自学C++基础的笔记

Contents of this book (Chapter 1-16)#

---

Chapter 2#

const#

const double PI = 3.14159 // PI值不变，常量命名为全大写

limits#

#include<limits>

内有各种变量类型的上限、下限

e.g INT_MAX = 2147483647

time(0)#

需要 #include<ctime>

显示当前时间距离1970.1.1 00:00:00 有多少秒

显示当前时间

static_cast#

static_cast demo

double x = 3.4;
y = static_cast<int>(x);
cout << "x=" << x << "y=" << y << endl;

Chapter 3#

bool#

bool demo

bool flag = true;
bool b1 = -1.5;
bool b2 = 0;
bool b3 = 1.5;

rand and srand#

rand and srand demo

#include<cstdlib>
int main()
{
    srand(seed); //更改rand的种子
    rand(); // 产生一个随机数
  
    return 0;
}

---

Chapter 4#

Mathematical Functions#

Mathematical Functions demo

#include <cmath>
int main()
{
    double x, y;
    double a, b;
  
    x = 10.5;
    a = 2.1;
    b = 2.3;
  
    y = log(x); //y=ln(x)
    y = log10(x); //y=lg(x)
    y = ceil(x); // 向inf取整
    y = floor(x); // 向-inf取整
    y = max(a,b);
    y = min(a,b);
  
    return 0;
}

Character Functions#

Character functions demo

#include <cctype>
#include <iostream>
int main()
{
    char ch = 'A';
    cout << isdigit(ch) << endl;
    cout << isalpha(ch) << endl;
    cout << isalnum(ch) << endl;
    cout << islower(ch) << endl;
    cout << isupper(ch) << endl;
    cout << isspace(ch) << endl;
    cout << tolower(ch) << endl; //返回小写字母，但是是数值，得用static_cast<char>转换
    cout << toupper(ch) << endl; //返回大写字母，但是是数值，得用static_cast<char>转换
    cout << static_cast<char>(tolower(ch)) << endl;
    cout << static_cast<char>(toupper(ch)) << endl;
  
    return 0;
}

string#

string 基础#

Basics of string

#include <string>
string str = "ABCD";
str.length();
str.at(0);
str[0];

string 拼接#

string concat

string s3 = s2 + s1;
s = s += "ABC";

比较大小：按ASCII码依次比较#

string读入#

string input

string str;
cin >> str; //遇到空白会停止读取
getline(cin, str, end); //直到end出现才停止，默认值为"\n"

cout 进阶#

**#include <iomanip>**

setprecision(n)#

setprecision demo

double number = 12.34567;
cout << setprecision(3) << number << endl; // 12.3 总共保留三位

The setprecision manipulator remains in effect until the precistion is changed!

fixed#

fixed demo

cout << 232123434.357; //2.32123e+08
cout << fixed << 232123434.357; // 232123434.357000 默认保留小数点后六位
cout << fixed << setprecision(2) << 345.123; //fixed 后的setprecision(2)指保留小数点后两位

showpoint#

showpoint示例

cout << setprecision(6);
cout << 1.23 << endl; // 1.23
cout << showpoint << 1.23 << endl; // 1.23000
cout << showpoint << 123 << endl; // 123.000

setw(width)#

setw示例

cout << setw(8) << "C++" << setw(6) << 101 << endl;
// ▢▢▢▢▢C++▢▢▢101
cout << setw(8) << "C++" << 101 << endl; // setw(8)只控制"C++"输出，与101无关
// ▢▢▢▢▢C++101
cout << setw(8) << "Programming" << endl; // 长度大于8
// Programming

left and right#

left和right示例

cout << setw(8) << "C++" << setw(6) << 101 << endl; // 默认右对齐
// ▢▢▢▢▢C++▢▢▢101
cout << right;
cout << setw(8) << 1.23 << endl;
// ▢▢▢▢1.23
cout << left;
cout << setw(8) << 1.23 << endl;
// 1.23▢▢▢▢

simple file input and output#

write file#

写文件示例

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

int main()
{
    ofstream output; // 实例化ofstream类对象
  
    output.open("numbers.txt");// 若不存在，创建；若存在，重写
  
    output << 95 << " " << 56; // 写文件
  
    output.close(); // 关闭文件
  
    return 0;
}

read file#

读文件示例

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

int main()
{
    ifstream input; // 实例化对象
  
    input.open("numbers.txt"); // 打开文件，不存在会报错
  
    int s1, s2;
  
    input >> s1; // 读文件
    input >> s2;
    // 等效于 input >> s1 >> s2;
  
    input.close(); // 关闭文件
  
    return 0;
}

---

Chapter 6#

overloading functions#

函数重载示例

#include <iostream>
#include <cmath>

using namespace std;

void fun(int x1, int x2);
void fun(int x1, double x2);
void fun(double x1, double x2);

int main()
{
    // 根据输入参数的类型来确定调用哪个函数
    fun(4, 5);
    fun(4, 5.4);
    fun(4.0, 5.4);

    return 0;
}

void fun(int x1, int x2)
{
    cout << "0" << endl;
}

void fun(int x1, double x2)
{
    cout << "1" << endl;
}

void fun(double x1, double x2)
{
    cout << "2" << endl;
}

function prototype#

函数原型示例

#include <iostream>
using namespace std;

void fun(int, int); // 声明时无序写出形参名
void fun(double, double);

int main()
{
    fun(1, 2);
    fun(1.0, 2.0);
  
    return 0;
}

void fun(int x1, int x2)
{
    cout << 0 << endl;
}

void fun(double x1, double x2)
{
    cout << 1 << endl;
}

default arguments#

函数默认参数示例

void fun0(int x = 1)
{
    cout << 0 << endl;
}

void fun1(double x1 = 1, double x2 = 2)
{
    cout << 1 << endl;
}

void fun2(double x1, double x2 = 1)
{
    cout << 2 << endl;
}

fun0();
fun0(2);
fun1();
fun1(3);
//fun1( ,5);错误
fun1(1, 2);
fun2(3);
fun2(2,4);

constant reference parameters#

常数参数示例

int max(const int& num1, const int& num2)
{
    int result;
    result = num1 > num2 ? num1 : num2;
    return result;
}

---

Chapter 7#

Passing arrays to functions#

数组传参示例

#include <iostream>
using namespace std;

void m(int, int []);

int main()
{
    int x = 1;
    int y[10];
    y[0] = 1;
  
    m(x, y);
  
    cout << x << endl;
    cout << y[0] << endl;
  
    return 0;
}

void m(int number, int numbers[])
{
    number = 1000;
    numbers[0] = 555;
}

Preventing changes of array arguments in functions#

const type list[] 示例

void p(const int list[], int arraySize)
{
    list[0] = 100;//这是错误的，list是常量
}

// 含有const数组形参函数嵌套调用错误示例
void f1(int list[], int size)
{
    // Doing something
}

void f2(const int list[], int size)
{
    f1(list, size);//这是错误的，f1中形参list不是const
}

// 含有const数组形参函数嵌套调用正确示例
void f1(const int list[], int size)
{
    // Doing something
}

void f2(const int list[], int size)
{
    f1(list, size);//这是正确的，f1中形参list是const
}

return an array#

返回一个数组示例

// int[] fun(args);是错误的

//正确:将数组地址传入，然后修改其数组元素
void reverse(const int list[], int newList[], int size)
{
    for(int i = 0, j = size - 1; i < size; i++, j--)
    {
        newList[j] = list[i];
    }
}

---

Chapter 8#

Passing two-dimensional arrays to functions#

二维数组传参示例

int sum(const int a[][COLUMN_SIZE], int rowSize) // 列数必须指定
{
    int total = 0;
    for(int i = 0; i < rowSize; row++)
    {
        for(int j = 0; j < COLUMN_SIZE; j++)
        {
            total += a[i][j];
        }
    }
  
    return total;
}

int matrix[rowSize][COLUMN_SIZE];
int y = sum(matrix, rowSize); // 调用

---

Object and Class#

Defining Classes and Creating Objects#

code#

类定义、对象创建示例

#include <iostream>
using namespace std;

class Circle
{
public:
    // data field
    // if you don't use the public word, the visibility is private by default
    double radius;
  
    // constructors
    Circle()
    {
        radius = 1;
    }
  
    Circle(double newRadius)
    {
        radius = newRadius;
    }
  
    // function
    double getArea()
    {
        return radius * radius * 3.14159;
    }
};

int main()
{
    Circle circle1;
    Circle circle2(25);
  
    cout << "radius: " << circle1.radius << " area: " << circle1.getArea() << endl;
    cout << "radius: " << circle2.radius << " area: " << circle2.getArea() << endl;
  
    return 0;
}

When you define a custom class, capitalize the first letter of each word in a class name.

UML notation#

UML 表示方式

// data field
dataFieldName: dataField Type

// constructor
ClassName(parameterName: parameterType)

// function
functionName(parameterName: parameterType): returnType

// "+" means public

Constructors#

Peculiarities#

• Constructors must have the same name as the calss itself.
• Constructors do not have a return type–not even void!
• Constructors are invoked when an object is created. Constructors play the role of initializing objects.

(A data field cannot be initialized when it is declared! like double radius = 5;)

• If we do not define a constructor, a no-arg constructor with an empty body is implicitly defined in the class. (Default constructor)

Constructor initializer list#

Data fields may be initialized in the constructor using an initializer list in the following syntax:

Constructor initializer list demo

ClassName(parameterList)
    : datafield1(value1), datafield2(value2)
{
    // Additional statements if needed
}

// Example
Circle::Circle()
    : radius(1)
{
  
}

Using an initializer list is necessary to initialize object data fields that don’t have a no-arg constructor.

Construction and Using Objects#

basics#

demo

ClassName ObjectName;
objectName.dataField;
objectName2 = objectName1; // deep copy
objectName.function(arguments);

object size#

Data are physically stored in an object, but functions are not. Since functions are shared by all objects of the same class, the compiler creates just one copy for sharing.

object size demo

#include <iostream>
using namespace std;

Class Circle
{
public:
    double radius;
  
    Circle()
    {
        radius = 1;
    }
  
    getArea()
    {
        return radius * radius * 3.14159;
    }
};

int main()
{
    Circle circle1;
    cout << sizeof(circle1);
  
    return 0;
}

Separating Class Definition from implementation#

Class Definition: list all the data fields, constructor prototypes, and function prototypes.
Class implementation implements the constructors and functions.
These are in two files, but both files should have the same name but different extension names(.h for data fields and .cpp for implementations).

Circle.h

#ifndef CIRCLE_H
#define CIRCLE_H

class Circle
{
public:
    double radius;
  
    Circle();
    Circle(double);
    double getArea();
};

#endif

Circle.cpp

#include "Circle.h"

Circle::Circle() //"Circle::" tells the functions are defined in Circle class
{
    radius = 1;
}

Circle::Circle(double newRadius)
{
    radius = newRadius;
}

double Circle::getArea()
{
    return radius * radius * 3.14159;
}

TestCircleWithHeader.cpp

#include <iostream>
#include "Circle.h"
using namespace std;

int main()
{
    Circle circle1;
    Circle circle2(5.0);
  
    cout << circle1.radius << circle1.getArea() << endl;
    cout << circle2.radius << circle2.getArea() << endl;
  
    return 0;
}

Inline Functions in Classes#

short functions are good candidates for inline functions.

Inline function demo

class A
{
public:
    A()
    {
        //Do something
    }
  
    double f1();
}

inline double A::f1()
{
    //Do something
    //return a number
}

Data Field Encapsulation#

Making data fields private protects data and makes the class easy to maintain.

• Data may be tampered with.
• Public data may makes the class difficult to maintain and vulnerable to bugs.

private data demo

class Circle
{
public: // public first
    Circle();
    Circle(double);
    double getArea();
    double getRadius(); // enable user access to radius
    void setRadius(double); // enable user to set radius
    /* 
    signature:
        returnType getPropertyName() for most type
        bool isPropertyName() for bool return type
        void setPropertyName(dataType propertyValue)
    */
  
private:
    double radius;
}

Object-Oriented Thinking#

Passing Objects to Functions#

passing objects by value and reference

#include <iostream>
#include "Circle.h"
using namespace std;

void passObjByValue(Circle c)
{
    c.setRadius(10);
}

void passObjByReference(Circle& c)
{
    c.setRadius(10);
}


int main()
{
    Circle circle1(5.0);
    Circle circle2(5.0);

    passObjByValue(circle1);
    passObjByReference(circle2);

    cout << circle1.getRadius() << " " << circle1.getArea() << endl;
    cout << circle2.getRadius() << " " << circle2.getArea() << endl;

    return 0;
}

Passing by reference is preferred, because it takes time and additional memory space to pass by value.

Array of Objects#

Array of Objects demo

#include <iostream>
#include "Circle.h"
using namespace std;

void setArrayRadius(Circle[], int);
void printArray(Circle[], int);

int main()
{
    const int SIZE = 10;
    Circle circleArray[SIZE];

    setArrayRadius(circleArray, SIZE);
    printArray(circleArray, SIZE);

    return 0;
}

void setArrayRadius(Circle circleArray[], int size)
{
    for(int i = 0; i < size ; i++)
    {
        circleArray[i].setRadius(i+1);
    }
}

void printArray(Circle circleArray[], int size)
{
    for(int i = 0; i < size; i++)
    {
        cout << circleArray[i].getRadius() << " " << circleArray[i].getArea() << endl;
    }
}

Instance and Static Members#

• A static variable is shared by all objects of the class
• A static function cannot access instance members of the class

UML graph#

Using of static members/functions#

Circle.h

#ifndef CIRCLE_H
#define CIRCLE_H

class Circle
{
public:
    Circle();
    Circle(double);
    double getRadius();
    void setRadius(double);
    double getArea();
    static int getNumberOfObjects(); // using static functions to get static members
  
private:
    double radius;
    static int numberOfObjects;
};

#endif

Circle.cpp

#include "Circle.h"

int Circle::numberOfObjects = 0; // define static members in cpp files

Circle::Circle() //"Circle::" tells the functions are defined in Circle class
{
    radius = 1;
    numberOfObjects++; // the static members can be accessed in constructors
}

Circle::Circle(double newRadius)
{
    radius = newRadius;
    numberOfObjects++;
}

double Circle::getRadius()
{
    return radius;
}

void Circle::setRadius(double newRadius)
{
    radius = newRadius >=0 ? newRadius : -newRadius;
}

double Circle::getArea()
{
    return radius * radius * 3.14159;
}

int Circle::getNumberOfObjects()
{
    return numberOfObjects;
}

main.cpp

#include <iostream>
#include "Circle.h"
using namespace std;

int main()
{
    cout << Circle::getNumberOfObjects() << endl; 
    /* 
    static members can be accessed before the object been created.
    static functions can be invoked before the object been created.
    */
    Circle circle1;
    cout << circle1.getNumberOfObjects() << endl;
    Circle circle2(4.0);
    cout << circle2.getNumberOfObjects() << endl;
  
    /*
    static functions can be invoked by 
    ClassName::function() or ObjectName.function()
    */
  
    return 0;
}

• If a variable or a function is not dependent on a specific instance of the class, it should be a static variable or static function
• Using ClassName::functionName(args) to invoke a static function and ClassName::staticVariable to access static variables improves readability.

Constant Member Functions#

A const function should not change the value of any data fields in the object.

Circle.h

#ifndef CIRCLE_H
#define CIRCLE_H

class Circle
{
public:
    Circle();
    Circle(double);
    double getRadius() const;
    void setRadius(double);
    double getArea() const;
    static int getNumberOfObjects();
  
private:
    double radius;
    static int numberOfObjects;
};

#endif

Circle.cpp

#include "Circle.h"

int Circle::numberOfObjects = 0;

Circle::Circle() //"Circle::" tells the functions are defined in Circle class
{
    radius = 1;
    numberOfObjects++;
}

Circle::Circle(double newRadius)
{
    radius = newRadius;
    numberOfObjects++;
}

double Circle::getRadius() const
{
    return radius;
}

void Circle::setRadius(double newRadius)
{
    radius = newRadius >=0 ? newRadius : -newRadius;
}

double Circle::getArea() const
{
    return radius * radius * 3.14159;
}

int Circle::getNumberOfObjects()
{
    return numberOfObjects;
}

main.cpp

#include <iostream>
#include "Circle.h"
using namespace std;

void printCircle(const Circle& c)
{
    cout << c.getRadius() << " " << c.getArea() << endl;
}
/*
A const member function should not change the value of any data fields in the object,
so instance get function should always be defined as a constant member function.

If a function does not change the object being passed like printCircle, you should 
define the parameters constant using const keyword, and member functions being 
invoked in the function should be const member functions. 
*/

int main()
{
    Circle circle1;
    printCircle(circle1);

    return 0;
}

Object Composition#

An object can contain another object. The relationship between the two is called composition.

Aggregation and composition#

The owner object is called an aggregating object and its class an aggregating class. The subject object is called an agggregated object and its class an aggregated class.
An object may be owned by several other aggregating objects. If an object is exclusively owned by an aggregating object, the relationship between the object and its aggregation object is referred to as composition.

UML graph#

• Filled diamond is attached to an aggregating class to denote the composition relationship.
• An empty diamond is attached to an aggregating class to denote the aggregation relationship.

Aggregation demo

class Name
{
    // something
}

class Address
{
    // something
}

class Student
{
private:
    Name name;
    Adddress address;
    // something
}

**Aggregation may exist between objects of the same class. **

Aggregation exist between objects of the same class.

class Person
{
private:
    Person teammates[3];
}

Thinking in Objects#

• The procedural paradigm focuses on designing functions. The object oriented paradigm couples data and functions together into objects.
• Software design using the object-oriented paradigm focuses on objects and operations on objects.

Class Design Guidelines#

• Cohesion
  • A class describe a single entity, all the class operations should logically fit together to support a coherent purpose.
• Consistency:
  • Follow standard programming style and naming conventions. Choose informative names for classes, data fields, and functions. Placing data declaration after the functions and place constructors before functions.
  • Choose the same names for similar operations using function overloading.
  • Consistently provide a public no-arg constructor.
• Encapsulation
  • Using private modifier to hide data.
• Clarity
  • A class should have a clear contract that is easy to explain and understand.
• Completeness
  • A class should provide a variety of ways for customization through properties and functions for wide range of applications.
• Instance vs. Static

---

Pointers and Dynamic memory management#

Using const with Pointers#

A constant pointer points to a constant memory location, but the actual value in the memory location can be changed.

Using const with Pointers

#include <iostream>
using namespace std;

int main()
{
	double radius = 5;
    double length = 5;

	double* const p1 = &radius; // constant pointer
	const double* p2 = &length; // constant data

	radius = 4;
	length = 6;
	// the value can be modify

	*p1 = 8;
	// p1 = p2 is wrong
	cout << *p1 << endl;

	cout << *p2 << endl;
	p2 = p1;
    // *p2 = *p1 is wrong
    cout << *p2 << endl;

    cout << "ok" << endl;

    return 0;
}

Passing Pointer Arguments in a Function Call#

A pointer argument can be passed by value or by reference

Four swap functions demo

#include <iostream>
using namespace std;

void swap1(int, int);
void swap2(int&, int&);
void swap3(int*, int*);
void swap4(int* &, int* &);

int main()
{
    int num1 = 1;
    int num2 = 2;
    int num3 = 3;
    int num4 = 4;
    int* p1 = &num3;
    int* p2 = &num4;
  
    swap1(num1, num2);
    cout << num1 << " " << num2 << endl;
    swap2(num1, num2);
    cout << num1 << " " << num2 << endl;
  
    swap3(p1, p2);
    cout << *p1 << " " << *p2 << endl;
    cout << p1 << " " << p2 << endl;
  
    *p1 = 3;
    *p2 = 4;
    swap4(p1, p2);
    cout << *p1 << " " << *p2 << endl;
    cout << p1 << " " << p2 << endl;
    return 0;
}

void swap1(int num1, int num2) // pass by value
{
    int t = num1;
    num1 = num2;
    num2 = t;
}

void swap2(int& num1, int& num2) // pass by reference
{
    int t = num1;
    num1 = num2;
    num2 = t;
}

void swap3(int* p1, int* p2) // pass two pointers by value
{
    int t = *p1;
    *p1 = *p2;
    *p2 = t;
}

void swap4(int* &p1, int* &p2) // pass two pointers by reference
{
    int *pt = p1;
    p1 = p2;
    p2 = pt;
}

Returning a Pointer from Functions#

return a pointer

int *reverse(int* list, int size)
{
    for(int i = 0, j = size - 1; i < j; i++, j--)
    {
        int temp = list[j];
        list[j] = list[i];
        list[i] = temp;
    }
  
    return list;
}

Useful Array Functions#

Usefun Array Functions demo

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

void printArray(const int* list, int size)
{
    for(int i = 0; i < size; i++)
    {
        cout << *(list + i) << " ";
    }
    cout << endl;
}

int main()
{
    const int SIZE = 6;
    int list[SIZE] = {1, 2, 3, 4, 5, 6};

    random_shuffle(list, list + SIZE);
    printArray(list, SIZE);

    sort(list, list + SIZE);
    printArray(list, SIZE);

    int* pmin = NULL;
    int* pmax = NULL;
    int* p = NULL;

    pmin = min_element(list, list + SIZE);
    cout << *pmin << " " << pmin - list << endl;

    pmax = max_element(list, list + SIZE);
    cout << *pmax << " " << pmax - list << endl;

    int key1 = 4;
    int key2 = 10;

    p = find(list, list + SIZE, key1);
    cout << p - list << endl;
    p = find(list, list + SIZE, key2);
    cout << p - list << endl;

    return 0;
}

Dynamic Persistent Memory Allocation#

A new operator can be used to create persistent memory at runtime for primitive type values, arrays, and objects.

C++ allocates local variables in the stack, but the memory allocated by the new operator is in an area of memory called heap. The heap memory remains available until you explicitly free it or the program terminates.

Allocation#

new operator demo

#include <iostream>
using namespace std;

int* reverse1(const int* list, const int SIZE) // wrong reverse
{
    int result[SIZE];
  
    for (int i = 0, j = size - 1; i < size; i++, j--)
    {
        result[j] = list[i];
    }
  
    return result;
    /*
    example11-8.cpp:15:9: warning: address of 
    local variable 'result' returned [-Wreturn-local-addr]
    */
}

int* reverse2(const int* list, const int SIZE) // right reverse
{
    int* list = new int[SIZE];
  
    for (int i = 0, j = size - 1; i < size; i++, j--)
    {
        result[j] = list[i];
    }
  
    return result;
}

int main()
{
    const int SIZE = 6;
    int list[SIZE] = {1, 2, 3, 4, 5, 6};
    int *list1 = reverse1(list, SIZE);
    int *list2 = reverse2(list, SIZE);
  
    printArray()
}

• int* p = new int(4);means allocate memory space for an int variable initialized to 4
• int* p = new int[size];means allocate dynamic array

For creating dynamic objects, you can use

• ClassName* pObject = new ClassName(); or ClassName* pObject = new ClassName; for no-arg constructor.
• ClassName* pObject = new ClassName(arguments); for creating an object using the constructor with arguments.

Creating objects using the new operator

string* p = new string("aaaaaaa");
cout << (*p).substr(0, 3) << endl;
cout << p->substr(0, 4) << endl;
cout << p->length() << endl;

Delete#

**To explicitly free the memory creater by the new operator, use the delete operator for the pointer. Like **delete p;**or **delete [] list;

• Use the delete keyword only with the pointer that points to the memory created by the new operator.
• After the memory pointed by a pointer is freed, the value of the pointer becomes undefined. Do not apply the dereference operator * on dangling pointer.
• Do not reassign a pointer before deleting the memory to which it points. It may cause memory leak.

memory leak

int* p = new int;
*p = 45;
p = new int;
/*
The original memory space that holds value 45 is not accessible.
This memory can't be accessed and can't be deleted. This is memory leak.
*/

The this Pointer#

The this pointer points to the calling object itself

circle.cpp

Circle::Circle(double radius)
{
    this->radius = radius;
}

void Circle::setRadius(double radius)
{
    this->radius = radius >= 0 ? radius : -radius;
}

Destructors#

Every class has a destructor, which is called automatically when an object is deleted.

• Every class has a default destructor if the destructor is not explicitly defined.
• Destructors are named the same as class with a destructor defined, but put a tilde character(~) in the front
• Destructors have no return type and no arguments.

destructor

~Circle();

Circle::~Circle()
{
    numberOfObjects--;
}

Copy Constructors#

Every class has a copy constructor, which is used to copy objects.

ClassName(const ClassName&)

A default copy constructors is provided for each class implicitly, if it is not defined explicitly. The default copy constructir simply copied each data field in one object to its counterpart in the other object.

Shallow Copy#

Course.h

#ifndef COURSE_H
#define COURSE_H
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

class Course
{
public:
	Course();
	Course(const string& CourseName, int capacity);
	~Course();
	string getCourseName() const;
	void addStudentName(const string& name);
	void dropStudent(const string& name);
	string* getStudents() const;
	int getNumberOfStudents() const;

private:
	string CourseName;
	string* students;
	int numberOfStudents;
	int capacity;
};

#endif

main.cpp

#include "Course.h"

int main()
{
	Course course1("C++", 10);
	Course course2(course1);
	course1.addStudentName("San Zhang");
	course2.addStudentName("Si Li");

	string* p1 = course1.getStudents();
	string* p2 = course2.getStudents();

	cout << *p1 << endl;
	cout << *p2 << endl;

	return 0;

}

Course.cpp

#include "Course.h"

Course::Course()
{
	CourseName = "undefined";
	numberOfStudents = 0;
	capacity = 0;
}

Course::Course(const string& CourseName, int capacity)
{
	this->CourseName = CourseName;
	this->capacity = capacity;
	numberOfStudents = 0;
	students = new string[capacity];
}

Course::~Course()
{
	delete[] students;
}

string Course::getCourseName() const
{
	return CourseName;
}

void Course::addStudentName(const string& name)
{
	if (numberOfStudents < capacity)
	{
		students[numberOfStudents++] = name;

	}
	else
	{
		cout << "Can not add more students!" << endl;
	}
}

void Course::dropStudent(const string& name)
{
	if (name.length() == 0)
	{
		cout << "The lenth of name must greater than zero!" << endl;
		return;
	}

	string* p = find(students, students + capacity, name);
	int index = p - students;

	if (index >= 0 && index < capacity)
	{
		for (int i = index; i < numberOfStudents - 1; i++)
		{
			students[i] = students[i + 1];
		}
		students[numberOfStudents - 1].clear();
		numberOfStudents--;
	}
	else 
	{
		cout << name << " do not in the list of students in " << CourseName << "!" <<endl;
	}
}

string* Course::getStudents() const
{
	return students;
}

int Course::getNumberOfStudents() const
{
	return numberOfStudents;
}

The program will display “Si Li” twice and it will cause error before the space for students in course1 is freed (students of course2 have no space!)

Deep Copy#

Customizing Copy Constructors

Course(const Course&);

Course::Course(const Course& course)
{
	CourseName = course.CourseName;
	numberOfStudents = course.numberOfStudents;
	capacity = course.capacity;
	students = new string[capacity];
	for (int i = 0; i < numberOfStudents; i++)
	{
		students[i] = course.students[i];
	}
}

---

Inheritance and Polymorphism#

Base Classes and Derived Classes#

**Inheritance enables you to define a general class (i.e., a base class) and later extend it to more specialized classes (i.e., derived classes). **

UML graph#

Syntax#

class derivedClassName : public baseClassName

• All the public member in bass class are inherited in derived class
• But the private data fields can not be accessed in the derived class. You can only use get or set functions to read or modify them.
• A derived class and its base class must have the is-a relationship.
• Not all “is-a” relationships should be modeled using inheritance. For class A to extend class B, A should contain more detailed information than B.
• C++ allows you to derive a derived class from several classes. This capability is known as multiple inheritance.

Generic Programming#

An object of a derived class can be passed wherever an object of a base type parameter is required. Thus a function can be used generically for a wide range of object arguments. This is known as generic programming.

Generic Programming demo

void display(BaseClass &obj)
{
    // something  
}

BaseClass obj1;
DerivedClass1 obj2;
DerivedClass2 obj3;

display(obj1);
display(obj2);
display(obj3);

Constructors and Destructors#

Calling Base Class Constructors#

Calling Base Class Constructors syntax

// function 1
// invoke no-arg constructor of the base class
DerivedClass(parameterList) : BaseClass() //bracket after BaseClass can be omitted
{
    // something
}

// function 2
// invoke constructor with specific arguments of the base class
DerivedClass(parameterList) : BaseClass(argumentList)
{
    setData1(data1);
    // something
}

// function 3
// equals to function 2
DerivedClass(parameterList) : BaseClass(argumentList), data1(data1)
{
    // something
}

Constructor and Destructor Chaining#

**The constructor of a derived class first calls its base class’s constructor before it executes its own code. The destructor of a derived class executes its own code then automatically calls its base class’s destructor. **

**Cautions: **

• If a class is designed to be extended, it is better to provide a no-arg constructor to avoid programming errors.

wrong example

class Fruit
{
public:
 Fruit(int id)
 {
 }
};

class Apple: public Fruit // no-arg constructor has not be defined in Fruit Class!
{
public:
 Apple()
 {
 }
};

• If the base class has a customized copy constructor and assignment operator, you should customize these in the derived classes to ensure that the data fields in the base class are properly copied.

example

Child::Child(const Child& object): Parent(object)
{
 // Write the code for copying data fields in Child
}

/*
The code for the assignment operator in Child would typically look like this:
Child& Child::operator=(const Child& object)
*/
{
 Parent::operator(object);
 // Write the code for copying data fields in Child
}

Redefining Functions#

A function defined in the base class can be redefined in the derived classes.

To redefine a base class’s function in the derived class, you need to add the function’s prototype in the derived class’s header file, and provide a new implementation for the function in the derived class’s implementation file.

Polymorphism#

Polymorphism means that a variable of a supertype can refer to a subtype object.

For example, every circle is a geometric object, but not every geometric object is a circle. Therefore, you can always pass an instance of a derived class to a parameter of its base class type.

Virtual Functions and Dynamic Binding#

A function can be implemented in several classes along the inheritance chain. Virtual functions enable the system to decide which function is invoked at runtime based on the actual type of the object. The capability of determining which function to invoke at runtime is known as dynamic binding.

virtual function demo

#include <iostream>
#include "GeometricObject.h"
#include "DerivedCircle.h"
#include "DerivedRectangle.h"   
using namespace std;

void displayGeometricObject(const GeometricObject& g)
{
    cout << g.toString() << endl;
}

int main()
{
    GeometricObject geometricObject;
    displayGeometricObject(geometricObject);
  
    Circle circle(5);
    displayGeometricObject(circle);
 
    Rectangle rectangle(4, 6);
    displayGeometricObject(rectangle);
 
    return 0;
}

/*
if toString function is defined in GeometricObject.h like:
string toString() const;

output:
    Geometric Object
    Geometric Object
    Geometric Object
  
if toString function is defined in GeometricObject.h like:
virtual string toString() const;

output:
    Geometric Object
    Circle Object
    Rectangle Object
*/

**To enable dynamic binding for a function, you need to do two things: **

• The function must be defined virtual in the base class.
• The variable that references the object must be passed by reference or passed as a pointer in the virtual function

Note

• Static Binding: The declared type of the variable decides which function to match at compile time. The compiler finds a matching function according to parameter type, number of parameters, and order of the parameters at compile time.
• Dynamic Binding: Dynamically binds the implementation of the function at runtime, decided by the actual class of the object referenced by the variable.
• If a function defined in a base class needs to be redefined in its derived classes, you should define it virtual to avoid confusions and mistakes. On the other hand, if a function will not be redefined, it is more efficient not to declare it virtual, because more time and system resource are required to bind virtual functions dynamically at runtime.

The protected keyword#

Keyword	Who can access?
public	inside the class/ friend functions/ friend classes
protected	inside the class/ friend functions/ friend classes/ derived classes
private	inside the class/ any other class

Abstract Classes and Pure Virtual Functions#

**An abstract class cannot be used to create objects. An abstract class can contain abstract functions, which are implemented in concrete derived classes. **

For example, getArea function can not be implemented in GeometricObject class, but can be implemented in the Circle class or Rectangle class. So we can define getArea in GeometricObject class as an abstract funcions(Pure Virtual Functions). Then GeometricObject class is a abstract class which cannot be used to create objects.

syntax: virtual type functionName(parameterList) = 0; The “= 0” notation indicates that this function is a pure virtual function. A pure virtual function does not have a body or implementation in the base class.

Casting: static_cast versus dynamic_cast#

The dynamic_cast operator can be used to cast an object to its actual type at runtime.

dynamic_cast can be performed only on the pointer or the reference of a polymorphic type; i.e., the type contains a virtual function. dynamic_cast can be used to check whether casting is performed successfully at runtime. static_cast is performed at compile time.

casting demo

// upcasting
BaseClass* p = new DerivedClass; // can be performed implicitly.

// downcasting
DerivedClass* p1;
p1 = static_cast<DerivedClass*>(p);
// or
p1 = dynamic_cast<DerivedClass*>(p);

Example: GeometricObject, Circle, Rectangle#

GeometricObject.h

#ifndef GEOMETRICOBJECT_H
#define GEOMETRICOBJECT_H
#include <string>
#include <iostream>
using namespace std;

class GeometricObject
{
public:
	GeometricObject();
	GeometricObject(const string& color, bool filled);
	virtual ~GeometricObject();
	string getColor() const;
	void setColor(const string& color);
	bool isFilled() const;
	void setFilled(bool filled);
	virtual string toString() const;
	//virtual double getArea() const = 0;
	//virtual double getPerimeter() const = 0;
private:
	string color;
	bool filled;
};

#endif

GeometricObject.cpp

#include "GeometricObject.h"

GeometricObject::GeometricObject()
{
	color = "white";
	filled = false;
}

GeometricObject::GeometricObject(const string& color, bool filled)
{
	this->color = color;
	this->filled = filled;
}

GeometricObject::~GeometricObject()
{
	cout << "Geometric Object destroyed!" << endl;
}

string GeometricObject::getColor() const
{
	return color;
}

void GeometricObject::setColor(const string& color)
{
	this->color = color;
}

bool GeometricObject::isFilled() const
{
	return filled;
}

void GeometricObject::setFilled(bool filled)
{
	this->filled = filled;
}

string GeometricObject::toString() const
{
	return "Geometric Object";
}

Circle.h

#ifndef CIRCLE_H
#define CIRCLE_H
#include "GeometricObject.h"

class Circle : public GeometricObject
{
public:
	Circle();
	Circle(double radius);
	Circle(double radius, const string& color, bool filled);
	~Circle();
	double getRadius() const;
	void setRadius(double);
	double getArea() const;
	double getPerimeter() const;
	double getDiameter() const;
	string toString() const;

private:
	double radius;
};

#endif

Circle.cpp

#include "Circle.h"

Circle::Circle()
{
	radius = 1;
}

Circle::Circle(double radius)
{
	setRadius(radius);
}

Circle::Circle(double radius, const string& color, bool filled)
{
	setRadius(radius);
	setColor(color);
	// this->color = color; Illgal since color is private in the base Class
	setFilled(filled);
}

Circle::~Circle()
{
	cout << "Circle Object destroyed!" << endl;
}

double Circle::getRadius() const
{
	return radius;
}

void Circle::setRadius(double radius)
{
	this->radius = radius >= 0 ? radius : -radius;
}

double Circle::getArea() const
{
	return radius * radius * 3.14159;
}

double Circle::getPerimeter() const
{
	return 2 * 3.14159 * radius;
}

double Circle::getDiameter() const
{
	return 2 * radius;
}

string Circle::toString() const
{
	return "Circle Object";
}

Rectangle.h

#ifndef RECTANGLE_H
#define RECTANGLE_H
#include "GeometricObject.h"

class Rectangle : public GeometricObject
{
public:
	Rectangle();
	Rectangle(double width, double height);
	Rectangle(double width, double height, const string& color, bool filled);
	~Rectangle();
	double getWidth() const;
	void setWidth(double);
	double getHeight() const;
	void setHeight(double);
	double getArea() const;
	double getPerimeter() const;
	string toString() const;

private:
	double width;
	double height;
};

#endif

Rectangle.cpp

#include "Rectangle.h"

Rectangle::Rectangle()
{
	width = 1;
	height = 1;
}

Rectangle::Rectangle(double width, double height)
{
	setWidth(width);
	setHeight(height);
}

Rectangle::Rectangle(double width, double height, const string& color, bool filled) 
	: GeometricObject(color, filled)
{
	setWidth(width);
	setHeight(height);
}

Rectangle::~Rectangle()
{
	cout << "Rectangle Object destroyed!" << endl;
}

double Rectangle::getWidth() const
{
	return width;
}

void Rectangle::setWidth(double width)
{
	this->width = width >= 0 ? width : -width;
}

double Rectangle::getHeight() const
{
	return height;
}

void Rectangle::setHeight(double height)
{
	this->height = height >= 0 ? height : -height;
}

double Rectangle::getArea() const
{
	return width * height;
}

double Rectangle::getPerimeter() const
{
	return 2 * (width + height);
}

string Rectangle::toString() const
{
	return "Rectangle Object";
}

main.cpp

#include <iostream>
#include <typeinfo>
#include "GeometricObject.h"
#include "Circle.h"
#include "Rectangle.h"
using namespace std;

void displayType1(const GeometricObject obj)
{
	cout << obj.toString() << endl;
}

void displayType2(const GeometricObject& obj)
{
	cout << obj.toString() << endl;
}

void displayType3(const GeometricObject* obj)
{
	cout << obj->toString() << endl;
}

void displayObj(GeometricObject &obj)
{
	GeometricObject* p = &obj;

	Circle* p1 = dynamic_cast<Circle*>(p);
	Rectangle* p2 = dynamic_cast<Rectangle*>(p);

	cout << typeid(*p).name() << endl;

	if (p1 != NULL)
	{
		cout << "radius: " << p1->getRadius() << endl;
	}

	if (p2 != NULL)
	{
		cout << "width: " << p2->getWidth() << endl;
		cout << "height: " << p2->getHeight() << endl;
	}
}

int main()
{
	GeometricObject obj;
	obj.setColor("red");
	obj.setFilled(true);
	cout << obj.toString() << endl
		<< "color: " << obj.getColor() << endl
		<< "filled: " << obj.isFilled() << endl;

	cout << "-------------------------------" << endl;

	Circle circle(5);
	cout << circle.toString() << endl
		<< "radius: " << circle.getRadius() << endl
		<< "area:" << circle.getArea() << endl
		<< "Perimeter: " << circle.getPerimeter() << endl
		<< "color: " << circle.getColor() << endl
		<< "filled: " << circle.isFilled() << endl;

	cout << "-------------------------------" << endl;

	Rectangle rectangle(2, 3, "blue", true);
	cout << rectangle.toString() << endl
		<< "width: " << rectangle.getWidth() << endl
		<< "height: " << rectangle.getHeight() << endl
		<< "area:" << rectangle.getArea() << endl
		<< "Perimeter: " << rectangle.getPerimeter() << endl
		<< "color: " << rectangle.getColor() << endl
		<< "filled: " << rectangle.isFilled() << endl;

	cout << "-------------------------------" << endl;
	displayType1(obj);
	displayType1(circle);
	displayType1(rectangle);
	displayType2(obj);
	displayType2(circle);
	displayType2(rectangle);
	displayType3(&obj);
	displayType3(&circle);
	displayType3(&rectangle);

	cout << "-------------------------------" << endl;
	cout << "Area: " << circle.getArea() << endl;
	cout << "Perimeter: " << circle.getPerimeter() << endl;
	cout << "Area: " << rectangle.getArea() << endl;
	cout << "Perimeter: " << rectangle.getPerimeter() << endl;

	cout << "-------------------------------" << endl;
	displayObj(circle);
	displayObj(rectangle);

	cout << "-------------------------------" << endl;
	GeometricObject* p = new Circle(5);
	delete p;

	cout << "-------------------------------" << endl;

	return 0;
}

---

Templates, Vectors, Stacks#

Templates Basics#

**Templates provide the capability to parameterize types in functions and classes. You can define functions or classes with generic types that can be substituted for concrete types by the compiler **

max function implemented by template

template <typename T>
T maxValue(const T& value1, const T& value2)
{
	return value1 > value2 ? value1 : value2;
}

// equals to these four overloading function
int maxValue(int value1, int value2)
{
    if (value1 > value2)
        return value1;
    else
        return value2;
}

double maxValue(double value1, double value2)
{
    if (value1 > value2)
        return value1;
    else
        return value2;
}
 
char maxValue(char value1, char value2)
{
    if (value1 > value2)
        return value1;
    else
        return value2;
}
 
string maxValue(string value1, string value2)
{
    if (value1 > value2)
        return value1;
    else
        return value2;
}

Cautions:
The generic maxValue function can be used to return a maximum of two values of any type, provided that:

• The two values have the same type
• The two values can be compared using the > operator

Occasionally, a template function may have more than one parameter. In this case, place the parameters together inside the brackets, separated by commas, such as template<typename T1, typename T2, typename T3>

Class Templates#

We use a improved stack class as example

stack implemented by template

#ifndef IMPROVEDSTACK_H
#define IMPROVEDSTACK_H

template `<typename T = int>` // default type is int
class Stack
{
public:
	Stack();
	Stack(int capacity);
	Stack(const Stack&);
	~Stack();
	bool empty() const;
	T peek() const;
	void push(T value);
	T pop();
	int getSize() const;
	int getCapacity() const;

private:
	T* elements;
	int size;
	int capacity;
	void ensureCapacity();
};

// template `<typename T>` must be put before the implementation
template `<typename T>`
Stack`<T>`::Stack() : size(0), capacity(16) // use Stack`<T>` rather than Stack
{
	elements = new T[capacity];
}

template `<typename T>`
Stack`<T>`::Stack(int capacity) : size(0)
{
	this->capacity = capacity;
	elements = new T[capacity];
}

template `<typename T>`
Stack`<T>`::Stack(const Stack& stack)
{
	capacity = stack.capacity;
	size = stack.size;
	elements = new T[capacity];
	for (int i = 0; i < size; i++)
	{
		elements[i] = stack.elements[i];
	}
}

template `<typename T>`
Stack`<T>`::~Stack()
{
	delete[] elements;
}

template `<typename T>`
bool Stack`<T>`::empty() const
{
	return size == 0;
}

template `<typename T>`
T Stack`<T>`::peek() const
{
	return elements[size - 1];
}

template `<typename T>`
void Stack`<T>`::push(T value)
{
	ensureCapacity();
	elements[size++] = value;
}

template `<typename T>`
T Stack`<T>`::pop()
{
	return elements[--size];
}

template `<typename T>`
int Stack`<T>`::getSize() const
{
	return size;
}

template `<typename T>`
void Stack`<T>`::ensureCapacity()
{
	if (size >= capacity)
	{
		T* old = elements;
		capacity = capacity * 2;
		elements = new T[capacity];
		for (int i = 0; i < size; i++)
		{
			elements[i] = old[i];
		}

    delete[] old;
    }

}

template `<typename T>`
int Stack`<T>`::getCapacity() const
{
	return capacity;
}

#endif // !IMPROVEDSTACK_H

vector Class#

C++ provides the vector class, which is more flexible than arrays. You can use a vector object just like an array, but a vector’s size can grow automatically if needed.

Use vector class

#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename T>
T sum(vector<vector<T> > &matrix) // a function to calculate the sum of a matrix
{
	T result = 0;
	for (unsigned i = 0; i < matrix.size(); i++)
	{
		for (unsigned j = 0; j < matrix[0].size(); j++)
		{
			result += matrix[i][j];
		}
	}

	return result;
}

int main()
{
	vector <int> intVector;
	vector <string> stringVector(4);

	cout << "size of int vector: " << intVector.size() << endl;
	cout << "size of string vector: " << stringVector.size() << endl;
	cout << "capacity of int vector: " << intVector.capacity() << endl;
	cout << "capacity of string vector: " << stringVector.capacity() << endl;

	intVector.push_back(3);
	cout << (intVector[0] == intVector.at(0) ? "True" : "False") << endl;

	intVector.pop_back();

	for (int i = 0; i < 20; i++)
	{
		intVector.push_back(i + 1);
		cout << "size of int vector: " << intVector.size() << endl;
		cout << "capacity of int vector: " << intVector.capacity() << endl;
	}

	/*while (!intVector.empty())
	{
		cout << intVector[intVector.size()] << endl;
		cout << "size of int vector: " << intVector.size() << endl;
		cout << "capacity of int vector: " << intVector.capacity() << endl;
		intVector.pop_back();
	}*/

	vector <int> v;
	v.swap(intVector);
	cout << "size of int vector: " << v.size() << endl;
	cout << "capacity of int vector: " << v.capacity() << endl;
	for (unsigned i = 0; i < v.size(); i++)
	{
		cout << v.at(i) << " ";
	}
	cout << endl;

	intVector.clear();
	cout << "size of int vector: " << intVector.size() << endl;
	cout << "capacity of int vector: " << intVector.capacity() << endl;

	cout << "----------------------------" << endl;

	vector <vector <int> > matrix(4); // use vector to create a matrix
	for (unsigned i = 0; i < matrix.size(); i++)
	{
		matrix[i] = vector<int>(3);
	}

	for (int i = 0; i < matrix.size(); i++)
	{
		for (int j = 0; j < matrix[0].size(); j++)
		{
			matrix[i][j] = (i + 1) * (j + 1);
		}
	}

	for (int i = 0; i < matrix.size(); i++)
	{
		for (int j = 0; j < matrix[0].size(); j++)
		{
			cout << matrix[i][j] << " ";
		}
		cout << endl;
	}

	cout << "sum of matrix: " << sum(matrix) << endl;

	return 0;
}

---

Operator Overloading#

The Rational Class for this chapter#

**In this chapter, we will overload several operators for using Rational class more conveniently. **
And in this section, we implemented the Rational class without operator overloading first.

Rational.h

#ifndef RATIONAL_H 
#define RATIONAL_H

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

class Rational
{
    public:
    Rational();
    Rational(int numerator, int denominator);
    int getNumerator() const;
    int getDenominator() const;
    Rational add(const Rational& secondRational) const;
    Rational subtract(const Rational& secondRational) const;
    Rational multiply(const Rational& secondRational) const;
    Rational divide(const Rational& secondRational) const;
    int compareTo(const Rational& secondRational) const;
    bool equals(const Rational& secondRational) const;
    int intValue() const;
    double doubleValue() const;
    string toString() const;
  
    private:
    int numerator;
    int denominator;
    int gcd(int n, int d);
  
};

#endif // !RATIONAL_H 

Ratioanl.cpp

#include "Rational.h"

Rational::Rational()
{
    numerator = 0;
    denominator = 1;
}

Rational::Rational(int numerator, int denominator)
{
    int factor = gcd(numerator, denominator);
    this->numerator = numerator / factor * (denominator >= 0 ? 1 : -1);
    this->denominator = abs(denominator) / factor;
}

int Rational::getNumerator() const
{
    return numerator;
}

int Rational::getDenominator() const
{
    return denominator;
}

int Rational::gcd(int n, int d)
{
    n = abs(n);
    d = abs(d);
    int factor = 1;
  
    for (int i = 1; i <= d && i <= n; i++)
    {
        if (d % i == 0 && n % i == 0)
        {
            factor = i;
        }
    }
  
    return factor;
}

Rational Rational::add(const Rational& secondRational) const
{
    int n;
    int d;
  
    n = numerator * secondRational.getDenominator() + denominator * secondRational.getNumerator();
    d = denominator * secondRational.getDenominator();
  
    return Rational(n, d);
}

Rational Rational::subtract(const Rational& secondRational) const
{
    int n;
    int d;
  
    n = numerator * secondRational.getDenominator() - denominator * secondRational.getNumerator();
    d = denominator * secondRational.getDenominator();
  
    return Rational(n, d);
}

Rational Rational::multiply(const Rational& secondRational) const
{
    int n;
    int d;
  
    n = numerator * secondRational.getNumerator();
    d = denominator * secondRational.getDenominator();
  
    return Rational(n, d);
}

Rational Rational::divide(const Rational& secondRational) const
{
    int n;
    int d;
  
    n = numerator * secondRational.getDenominator();
    d = denominator * secondRational.getNumerator();
  
    return Rational(n, d);
}

int Rational::compareTo(const Rational& secondRational) const
{
    double v1 = this->doubleValue();
    double v2 = secondRational.doubleValue();
  
    if (v1 > v2)
    {
        return 1;
    }
  
    else if (v1 < v2)
    {
        return -1;
    }
  
    else
    {
        return 0;
    }
}

bool Rational::equals(const Rational& secondRational) const
{
    return compareTo(secondRational) == 0 ? true : false;
}

int Rational::intValue() const
{
    return numerator / denominator;
}

double Rational::doubleValue() const
{
    return 1.0* numerator / denominator;
}

string Rational::toString() const
{
    stringstream ss;
    ss << numerator;
  
    if (denominator > 1)
        ss << "/" << denominator;
  
    return ss.str();
}

Operator functions#

**If we want to compare two Rational objects, we can use the member function compareTo, but overloading <, >, <=, **>=is more conveniently.

overload < operator

// write in the defination of the Rational class
bool operator<(const Rational& secondRational) const;

// write in the Rational.cpp
bool Rational::operator<(const Rational& secondRational) const
{
    return compareTo(secondRational) < 0 ? true : false
}

**We can overload +, -, *, **/to make calculate Rational objects more conveniently.

overload +

Rational operator+(const Rational& secondRational) const;

Rational Rational::operator+(const Rational& secondRational) const
{
    return add(secondRational);
}

Notes:

• C++ allows to overload the operators in Table 14.1, but does not allow to create new operators.
• We cannot change the operator precedence and associativity by overloading
• Most operator are binary operators. Some are unary. We cannot change the number of operands by overloading.

Overloading the Subscript Operator#

**The subscript operator **[]is commonly defined to access and modify a data field or an element in an object.

overload []

// wrong overloading
/*
Rational r1(2, 3);
cout << r1[0] << r1[1] << endl; // ok
r1[0] = 5; // nope!
*/
int operator[](int index);

int Rational::operator[](int index)
{
    if(index == 0)
        return numerator;
    else
        return denominator;
}

// correct overloading
int& operator[](int index);

int& Rational::operator[](int index)
{
    if(index == 0)
        return numerator;
    else
        return denominator;
}

In C++, Lvalue (left value) refers to anything that can appear on the left side of the assignment operator (=) and Rvalue (right value) refers to anything that can appear ont the right side of the assignment operator.

If we want to overload a Lvalue operator, we should use return-by-reference.

Overloading Augmented Assignment Operator#

**For augmented assignment operators (+=, -=, *=, **/= and %=) **are Lvalue operators. We can define the augmented assignment operators as functions to return a value by reference. **

overload +=

Rational& operator+=(const Rational& secondRational);
Rational& Rational::operator+=(const Rational& secondRational)
{
    *this = add(secondRational);
    return *this;
}

Overloading the Unary Operator#

The unary + and – operators can be overloaded. Since the unary operator operates on the one operand that is the calling object itself, the unary function operator has no parameters.

overload unary operator -

Rational operator-();

Rational Rational::operator-()
{
    return Rational(-numerator, denominator);
}

Overloading the ++ and – Operator#

The ++ and -- operator may be prefix or postfix, and the methods of overloading prefix ++/-- and postfix ++/-- are different.

Prefix ++/-- is Lvalue operator, so it should return by reference.

overload prefix ++

Rational& operator++();

Rational& Rational::operator++()
{
    numerator += denominator;
    return *this;
}

Postfix ++/-- are defined with a special dummy parameter of the int type. So when we operator postfix ++/-- the function should have an int type dummy parameter. And Prefix ++/-- operator function do not have parameters.

overload postfix ++

Rational operator++(int);

Ratioanl Rational::operator++(int)
{
    Rational temp(numerator, denominator);
    numerator += denominator;
    return temp;
}

Overloading the Stream Operator#

friend Functions and friend Classes#

<< and >> must be implemented as friendnonmember functions. So we learn friendfunction and friend class first.

We can define a friend function or a friend class to enable it to access private members in another class.

friend class demo

#include <iostream>
using namespace std;

class Date
{
public:
    Date()
    {
        year = 2000;
        month = 1;
        day = 1;
    }
  
    friend class AccessDate;
  
private:
    int year;
    int month;
    int day;
}

class AccessDate
{
public:
    static void p()
    {
        Date birthDate();
        birthDate.year = 2001;
        cout << birthDate.year << endl;
    }
}

int main()
{
    AccessDate::p();
  
    return 0;
}

friend function demo

#include <iostream>
using namespace std;

class Date
{
public:
    Date()
    {
        year = 2000;
        month = 1;
        day = 1;
    }
  
    friend void p()
    {
        Date date;
        date.year = 2022;
        cout << date.year << endl;
    }
  
private:
    int year;
    int month;
    int day;   
}

int main()
{
    p();
  
    return 0;
}

Overloading << and >>#

The stream extraction (>>) and insertion (<<**) operators can be overloaded for performing input and output operations. **

If we want to display a Rational object r, we will use:

cout << r.toString() << endl;

Wouldn’t it be nice to be able to display r like the following?

cout << r << endl;

But we cannot overload the << operator as a member function for two operands cout is an instance of ostream class, not Rational class.

overload <<

class Rational
{
public
    // something
    friend ostream& operator<<(ostream& out, const Rational& rational);
  
private:
    // something
}

ostream& operator<<(ostream& out, const Rational& rational)
{
    out << rational.toString();
    // out << rational.numerator << "/" << rational.denominator;
    return out;
}

Similarly, we can overload >> like the following

overload >>

class Rational
{
public
    // something
    friend istream& operator>>(istream& in, const Rational& rational);
  
private:
    // something
}

istream& operator>>(istream& in, const Rational& rational)
{
    cout << "Enter Numerator: ";
    in >> rational.numerator;
  
    cout << "Enter Denominator: ";
    in >> rational.denominator;
  
    return in;
}

Automatic Type Conversions#

You can define functions to perform automatic conversion from an object to a primitive type value and vice versa.

C++ can perform certain type conversion automatically. For example, in 4 + 5.5, C++ convert 4 to 4.0 first.

If we want to convert a Rational object to a double value. Here is the implementation.

convert Rational object to double

operator double();

Rational::operator double()
{
    return doubleValue();
}

And if we want to convert a int variable to Rational number. We may use the following code.

convert int variable to Rational object

Rational(int numerator);

Rational::Rational(int numerator)
{
    this->numerator = numerator;
    denominator = 1;
}

A class can define the conversion function to convert an object to a primitive type value or define a conversion constructor to convert a primitive type value to an object, but not both simultaneously in the class. If both are defined, the compiler will report an ambiguity error.

Nonmember Functions for Overloading Operators#

**If an operator can be overloaded as a nonmember function, define it as a nonmember function to enable implicit type conversions. **

In previous sections, we implemented r1 + 4, but we cannot calculate 4 + r1, because the left operand is the calling object for the + operator and the left operand must be a Rational object.
To solve this problem, we may use the following code.

nonmember function for overload +

Rational(int numerator); // write in the class defination

// This constructor enables the integer to be converted to a Rational object
Rational::Rational(int numerator)
{
    this->numerator = numerator;
    denominator = 1;
}

Rational operator+(const Ratioanl& r1, const Rational& r2); // write in the outside of the class

Rational operator+(const Ratioanl& r1, const Rational& r2)
{
    return r1.add(r2);
}

Overloading the = Operators#

You need to overload the = operator to perform a customized copy operation for an object.

The behavior of the operator is the same as the copy constructor, both of these should be implemented explicitly if a data field in the class is a pointe that points to a dynamic generated array or object.

overload =

class Course
{
public:
    // something
  
    const Course& operator=(const Course& course);
  
private:
    string courseName;
    stirng* students;
    int capacity;
    int numerOfStudents;
}

const Course& Course::operator=(const Course& course)
{
    courseaName = course.courseName;
    numberOfStudents = course.numberOfStudents;
    capacity = course.capacity;
    students = new string[capacity];
  
    return *this;
}

The Rational Class with Overloaded Function Operators#

Rational.h

#ifndef RATIONAL_H 
#define RATIONAL_H

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

class Rational
{
public:
	Rational();
	Rational(int numerator, int denominator);
	int getNumerator() const;
	int getDenominator() const;
	Rational add(const Rational& secondRational) const;
	Rational subtract(const Rational& secondRational) const;
	Rational multiply(const Rational& secondRational) const;
	Rational divide(const Rational& secondRational) const;
	int compareTo(const Rational& secondRational) const;
	bool equals(const Rational& secondRational) const;
	int intValue() const;
	double doubleValue() const;
	string toString() const;
  
    // overloaded operators
  
    // Lvalue operators
	int& operator[](int index);
	Rational& operator+=(const Rational& secondRatioanl);
	Rational& operator-=(const Rational& secondRatioanl);
	Rational& operator*=(const Rational& secondRatioanl);
	Rational& operator/=(const Rational& secondRatioanl);
  
    // unary operators
	Rational operator+();
	Rational operator-();
  
    // prefix ++/--
	Rational& operator++();
	Rational& operator--();
  
    // postfix ++/--
	Rational operator++(int);
	Rational operator--(int);
  
    // stream operator
	friend ostream& operator<<(ostream& out, const Rational& rational);
	friend istream& operator>>(istream& in, Rational& rational);
  
    // convertion function
	Rational(int numerator);

private:
	int numerator;
	int denominator;
	int gcd(int n, int d);

};

// nonmember operator functions
Rational operator+(const Rational& r1, const Rational& r2);
Rational operator-(const Rational& r1, const Rational& r2);
Rational operator*(const Rational& r1, const Rational& r2);
Rational operator/(const Rational& r1, const Rational& r2);

bool operator<(const Rational& r1, const Rational& r2);
bool operator>(const Rational& r1, const Rational& r2);
bool operator<=(const Rational& r1, const Rational& r2);
bool operator>=(const Rational& r1, const Rational& r2);
bool operator==(const Rational& r1, const Rational& r2);
bool operator!=(const Rational& r1, const Rational& r2);

#endif // !RATIONAL_H 

Rational.cpp

#include "Rational.h"

Rational::Rational()
{
	numerator = 0;
	denominator = 1;
}

Rational::Rational(int numerator, int denominator)
{
	int factor = gcd(numerator, denominator);
	this->numerator = numerator / factor * (denominator >= 0 ? 1 : -1);
	this->denominator = abs(denominator) / factor;
}

int Rational::getNumerator() const
{
	return numerator;
}

int Rational::getDenominator() const
{
	return denominator;
}

int Rational::gcd(int n, int d)
{
	n = abs(n);
	d = abs(d);
	int factor = 1;

	for (int i = 1; i <= d && i <= n; i++)
	{
		if (d % i == 0 && n % i == 0)
		{
			factor = i;
		}
	}

	return factor;
}

Rational Rational::add(const Rational& secondRational) const
{
	int n;
	int d;

	n = numerator * secondRational.getDenominator() + denominator * secondRational.getNumerator();
	d = denominator * secondRational.getDenominator();

	return Rational(n, d);
}

Rational Rational::subtract(const Rational& secondRational) const
{
	int n;
	int d;

	n = numerator * secondRational.getDenominator() - denominator * secondRational.getNumerator();
	d = denominator * secondRational.getDenominator();

	return Rational(n, d);
}

Rational Rational::multiply(const Rational& secondRational) const
{
	int n;
	int d;

	n = numerator * secondRational.getNumerator();
	d = denominator * secondRational.getDenominator();

	return Rational(n, d);
}

Rational Rational::divide(const Rational& secondRational) const
{
	int n;
	int d;

	n = numerator * secondRational.getDenominator();
	d = denominator * secondRational.getNumerator();

	return Rational(n, d);
}

int Rational::compareTo(const Rational& secondRational) const
{
	double v1 = this->doubleValue();
	double v2 = secondRational.doubleValue();

	if (v1 > v2)
	{
		return 1;
	}

	else if (v1 < v2)
	{
		return -1;
	}

	else
	{
		return 0;
	}
}

bool Rational::equals(const Rational& secondRational) const
{
	return compareTo(secondRational) == 0 ? true : false;
}

int Rational::intValue() const
{
	return numerator / denominator;
}

double Rational::doubleValue() const
{
	return 1.0* numerator / denominator;
}

string Rational::toString() const
{
	stringstream ss;
	ss << numerator;

	if (denominator > 1)
		ss << "/" << denominator;

	return ss.str();
}

int& Rational::operator[](int index)
{
	if (index == 0)
	{
		return numerator;
	}
	else
	{
		return denominator;
	}
}

Rational& Rational::operator+=(const Rational& secondRational)
{
	*this = add(secondRational);
	return *this;
}

Rational& Rational::operator-=(const Rational& secondRational)
{
	*this = subtract(secondRational);
	return *this;
}

Rational& Rational::operator*=(const Rational& secondRational)
{
	*this = multiply(secondRational);
	return *this;
}

Rational& Rational::operator/=(const Rational& secondRational)
{
	*this = divide(secondRational);
	return *this;
}

Rational Rational::operator+()
{
	return Rational(numerator, denominator);
}

Rational Rational::operator-()
{
	return Rational(-numerator, denominator);
}

Rational& Rational::operator++()
{
	numerator += denominator;
	return *this;
}

Rational Rational::operator++(int)
{
	Rational temp(numerator, denominator);
	numerator += denominator;
	return temp;
}

Rational& Rational::operator--()
{
	numerator -= denominator;
	return *this;
}

Rational Rational::operator--(int)
{
	Rational temp(numerator, denominator);
	numerator -= denominator;
	return temp;
}

ostream& operator<<(ostream& out, const Rational& rational)
{
	out << rational.toString();
	return out;
}

istream& operator>>(istream& in, Rational& rational)
{
	cout << "Enter Numerator: ";
	in >> rational.numerator;
	cout << "Enter Denominator: ";
	in >> rational.denominator;

	Rational r(rational.numerator, rational.denominator);
	rational.numerator = r.numerator;
	rational.denominator = r.denominator;

	return in;
}

Rational::Rational(int numerator)
{
	this->numerator = numerator;
	denominator = 1;
}

Rational operator+(const Rational& r1, const Rational& r2)
{
	return r1.add(r2);
}

Rational operator-(const Rational& r1, const Rational& r2)
{
	return r1.subtract(r2);
}

Rational operator*(const Rational& r1, const Rational& r2)
{
	return r1.multiply(r2);
}

Rational operator/(const Rational& r1, const Rational& r2)
{
	return r1.divide(r2);
}

bool operator<(const Rational& r1, const Rational& r2)
{
	return r1.compareTo(r2) < 0 ? true : false;
}

bool operator>(const Rational& r1, const Rational& r2)
{
	return r1.compareTo(r2) > 0 ? true : false;
}

bool operator<=(const Rational& r1, const Rational& r2)
{
	return r1.compareTo(r2) <= 0 ? true : false;
}

bool operator>=(const Rational& r1, const Rational& r2)
{
	return r1.compareTo(r2) >= 0 ? true : false;
}

bool operator==(const Rational& r1, const Rational& r2)
{
	return r1.equals(r2) == true ? true : false;
}

bool operator!=(const Rational& r1, const Rational& r2)
{
	return r1.equals(r2) == false ? true : false;
}

TestRationalClass.cpp

#include "Rational.h"
#include <iostream>
using namespace std;

int main()
{
	Rational r1(2, 3);
	Rational r2(4, 2);
  
    cout << "Test functions: " << endl;

	cout << r1.toString() << endl;
	cout << r2.toString() << endl;

	cout << r1.intValue() << endl;
	cout << r2.intValue() << endl;

	cout << r1.doubleValue() << endl;
	cout << r2.doubleValue() << endl;

	cout << (r1.add(r2)).toString() << endl;
	cout << (r1.subtract(r2)).toString() << endl;
	cout << (r1.multiply(r2)).toString() << endl;
	cout << (r1.divide(r2)).toString() << endl;

	cout << r1.compareTo(r2) << endl;
	cout << r1.equals(r2) << endl;

	cout << "-------------------------------" << endl;
  
    cout << "Test operator functions" << endl;
  
    Rational r3;
	cin >> r3;
	cout << r3 << endl;

    cout << r1 + 0.5 << endl;
	cout << 2 - r1 << endl;
	cout << 1 + r1 << endl;
	cout << r1 * 3 << endl;
	cout << 3 / r1 << endl;

	cout << ((3 > r1) ? "true" : "false") << endl;
	cout << ((10 < r1) ? "true" : "false") << endl;
	cout << ((2 >= r2) ? "true" : "false") << endl;
	cout << ((3 <= r2) ? "true" : "false") << endl;
	cout << ((2 == r2) ? "true" : "false") << endl;
	cout << ((3 != r2) ? "true" : "false") << endl;

	cout << r1[0] << " " << r1[1] << endl;
	cout << r2[0] << " " << r2[1] << endl;

	cout << (r1 += r2) << endl;
	cout << r1 << endl;
	cout << (r1 -= r2) << endl;
	cout << r1 << endl;
	cout << (r1 *= r2)  << endl;
	cout << r1 << endl;
	cout << (r1 /= r2) << endl;
	cout << r1 << endl;

	cout << (-r1).toString() << endl;
	cout << (r1++).toString() << endl;
	cout << r1.toString() << endl;
	cout << (++r1).toString() << endl;
	cout << r1.toString() << endl;
	cout << (r1--).toString() << endl;
	cout << r1.toString() << endl;
	cout << (--r1).toString() << endl;
	cout << r1.toString() << endl;

	return 0;
}

Note Points for Operator Overloading#

**The preceding sections introduced how to overload function operators. The following points are worth noting: **

• **Conversion functions: **
  • Conversion funcitons from a class type to a primitive type or from a primitive type to a class type cannot both be defined in the same class. Doing so would cause ambiguity errors, because the compiler cannot decide which conversion to perform. Often converting from a primitive type to a class type is more useful. So, we will define our Rational class to support automatic conversion from a primitive type to the Rational type.
• **Member or nonmember functions: **
  • Most operators can be overloaded either as member or nonmember functions. However, the =, [], ->, and () operators must be overloaded as member functions and << and >> operators must be overloaded as nonmember functions.
  • If an operator (i.e., +, -, *, /, %, <, <=, ==, !=, >, and >=) can be implemented either as a member or nonmember function, it is better to overload it as a nonmember function to enable automatic type conversion with symmetric operands.
• Lvalue:
  • If you want the returned object to be used as an Lvalue (i.e., used on the left-hand side of the assignment statement), you need to define the function to return a reference. The augmented assignment operators +=, -=, *=, /=, and %=, the prefix ++ and --operators, the subscript operator [], and the assignment operators = are Lvalue operators.

---

File Input and Output#

C++ provides the ifstream, ofstream, and fstream classes for processing and manipulating files. These classes are defined in the <fstream> header file.

Text I/O#

Writing Data to File#

The ofstream class can be used to write primitive data-type values, arrays, strings, and objects to a text file.

TextFileOutput.cpp

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

int main()
{
    // Create a file
    ofstream output;
    output.open("score.txt");
    // equals to
    // ofstream output("score.txt");

    output << "Zhang San" << " " << 90 << endl;
    output << "Lisi" << " " << 87 << endl;

    // close the file
    output.close()

    return 0;
}

• If a file already exists, its contents will be destroyed without warning!
• The directory separator should be “\” e.g output.open("D:\\example.txt");
• It is better to use a relative file name rather than absolute file name.

Reading Data from File#

The ifstream class can be used to read data from a text file.

TextFileInput.cpp

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

int main()
{
    ifstream input("score.txt");

    string name;
    int score;

    input >> name >> score;
    cout << name << score << endl;
    input >> name >> score;
    cout << name << score << endl;

    input.close()
  
    return 0;
}

• To read data correctly, we need to know exactly how data are stored.

Testing File Existence#

If the file does not exist when reading a file, the program will run and produce incorrect results. We can invoke the fail() function immediately after invoking the open function. If fail() returns true, it indicates that the file does not exist.

TestingFileExistence.cpp

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

int main()
{
    ifstream in("score.txt");

    if (input.fail())
    {
        cout << "File does not exist!" << endl;
    }
    else
    {
        in.close();
        cout << "File exists." << endl;
    }

    return 0;
}

Testing End of File#

We can invoke the eof() function on the input object to detect the end of file.

TestingEndOfFile.cpp

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

int main()
{
    ifstream input("score.txt")

    double sum = 0;
    double score;
    int count = 0;
  
    while(!input.eof())
    {
        input >> score;
        if(input.eof()) break;
        sum += score;
        count++;
    }

    // equals to
  
    /*
        while(input >> score)
        {
            sum += score;
            count++;
        }
    */

    cout << sum / count << endl;

    input.close();

    return 0;
}

• The statement input >> score is actually invoke an operator function. The function returns an object if a number is read, otherwise it returns NULL

Letting the User Enter a File name#

The file name passed to the input and output stream constructor or the open function must be a C-string in the standard C++. So we must use c_str() function in the string class is invoked to return a C-string from string object.

demo.cpp

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

int main()
{
    string filename;
    cout << "Enter a file name: ";
    cin >> filename;

    ofstream out(filename.c_str());

    out << "Hello World!" << endl;

    out.close();

    return 0;
}

Formatting Output#

The stream manipulators can be used to format console output as well as file output.
We can include <iomanip> to manipulate output in file.

WriteFormattedData.cpp

#incldue <iostream>
#inlcude <iomanip>
#include <fstream>
using namespace std;

int main()
{
    ofstream output;

    output << setw(6) << "John" << setw(2) << "T" << setw(4) << 87 << endl;
  
    output.close();

    return 0;
}

getline, get and put#

The getline function can be used to read a string that includes whitespace characters and the get/put function can be used to read and write a single character.

Syntax

• getline(ifstream& input, string s, char delimitChar);

The function stops reading characters when the delimiter character or eof is encountered. The delimitChar has a default value "\n". The getline function is defined in the iostream.

• get(); or get(char& ch);

The first version returns a character from the input. The second version passes a character reference argument, reads a character from the input, and stores it in ch. This function also returns the reference to the input object being used.

• put(char ch)

fstream and File Open Modes#

We can use fstream to create a file object for both input and output.

It is convenient to use fstream if a program needs to use the same stream object for both input and output. To open an fstream file, you have to specify a file open mode to tell C++ how the file will be used.

• Some of the file modes also can be used with ifstream and ofstream objects to open a file. For example, you may use the ios:app mode to open a file with an ofstream object so that you can append data to the file. However, for consistency and simplicity, **it is better to use the file modes with the **fstream objects.
• Several modes can be combined using the | operator. This is a bitwise inclusive-OR operator**. For example, to open an output file named city.txt for appending data, we can use the following statement: stream.open("city.txt", ios::out | ios::app);.

Testing Stream States#

The functions eof(), fail(), good(), and bad() can be used to test the states of stream operations.

Binary I/O#

The ios::binary mode can be used to open a file for binary input and output.
Computers do not differentiate binary files and text files. All files are stored in binary format, and thus all files are essentially binary files. Text I/O is built upon binary I/O to provide a level of abstraction for character encoding and decoding.

The write Function#

syntax:

streamObject.write(const char* s, int size); So we should pass standard C-string into write function.

BinaryCharOutput.cpp

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

int main()
{
    fstream binaryio("data.dat", ios::out | ios::binary);
    string s = "Hello";
    binaryio.write(s.c_str(), s.size());
    binaryio.close();

    return 0;
}

Often we need to write data other than characters. We can use reinterpret_cast operator to cast any pointer type of unrelated classes. It simply performs a binary copy of the value from one type to the other without altering the data.

syntax: reinterpret_cast<dataType*>(address); And in this case, the dataType is char*

BinaryIntOutput.cpp

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

int main()
{
    fstream binaryio("data.dat", ios::out | ios::binary);
    int num = 199;
    binaryio.write(reinterpret_cast<char*>(&num), sizeof(num));
    binaryio.close();

    return 0;
}

The read Function#

**syntax: **

streamObject.read(char* address, int size);

The size parameter indicates the maximum number of bytes read. The actual number of bytes read can be obtained from a member function gcount.

We can also use reinterpret_cast to cast bytes into types not char

BinaryIntInput.cpp

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

int main()
{
    fstream binaryio("data.dat", ios::in | ios::binary);
    int num;
    binaryio.read(reinterpret_cast<char*>(&num), sizeof(num));
    cout << num << endl;
    binaryio.close();

    return 0;
}

Random Access File#

The functions seekg() and seekp() can be used to move file pointer to any position in a random-access file for input and output.

The seekp("seek put") function is for the output stream, and the seekg("seek get")function is for the input stream. Each function has two versions with one argument or two arguments.

• With one argument, the argument is the absolut location.

  input.seekg(0);

  output.seekp(0);

• With two arguments, the first argument is a long integer that indicates an offset, and the second argument, known as the seek base, specifies where to calculate the offset from. The following are three possible seek base arguments.

Examples：

We can also use tellp and tellg functions to return the position of the file pointer in the file.

Updating Files#

We can update a binary file by opening a file using the mode ios::in | ios:out | ios::binary.
Often we need to update the contents of the file. You can open a file for both input and output.

For example: binaryio.open("data.dat"), ios::in | ios::out | ios::binary);

UpdatingFile.cpp

#include <iostream>
#include <fstream>
#include "Student.h" // Define the Student Class
using namespace std;

void display(const Student& student)
{
    // details omitted
}

int main()
{
    fstream binaryio;
    binaryio.open("student.dat", ios::in | ios::out | ios::binary);

    Student stu1;
    binaryio.seekg(sizeof(Student));
    binaryio.read(reinterpret_cast<char*>(&stu1), sizeof(Student));
    // initial name is Zhang San

    display(stu1);

    stu1.setName("Li si");
    binaryio.seekp(sizeof(Student));
    binaryio.write(reinterpret_cast<char*>(&stu1), sizeof(Student));

    Student stu2;
    binaryio.seekg(sizeof(Student));
    binaryio.read(reinterpret_cast<char*>(&stu2));

    display(stu2);

    binaryio.close();

    return 0;
}

---

Exception Handling#

Overview#

An exception is thrown using a throw statement and caught in a try-catch block.

QuotientWithException.cpp

#include <iostream>
using namespace std;

int main()
{
	cout << "Enter two integers: ";
	int n1, n2;

	cin >> n1 >> n2;

	try
	{
		if (n2 == 0)
			throw n1;

		cout << n1 << " / " << n2 << " = " << n1 / n2 << endl;
	}
	catch(int ex)
	{
		cout << n1 << " cannot divided by zero" << endl;
	}

	return 0;
}

The try block contains the code that is executed in normal circumstances. The catch block contains the code that is executed when n2 is zero. When n2 is zero, the program throws an exception by executing throw n1. However, after the catch block has been executed, the program control does not return to the throw statement; instead, it executes the next statement after the catch block.

If you are not interested in the contents of an exception object, the catch block parameter may be omitted.

catch block which parameter be omitted

try
{
    // ...
}

catch(int)
{
    cout << "Error occurred" << endl;
}

Advantages of Excpetion-Handling#

Exception handling enables the caller of the function to process the exception thrown from a function.

Without this capability, a function must handle the exception or terminate the program. Often, the called function does not know what to do in case of error. This is typically the case for the library function. The library function can detect the error, but only the caller knows what needs to be done when an error occurs. The fundamental idea of exception handling is to separate error detection (done in a called function) from error handling (done in the calling function).

Exception Classes#

You can use C++ standard exception classes to create exception objects and throw exceptions.
The catch block parameter in the preceding examples is the int type. A class type is often more useful.

The root class in this hierarchy is exception（defined in header <exception>）. It contains the virtual function what() that returns an exception object’s error message.

The runtime_error class (defined in header <exception>) is a base class for several standard exception classes that describes runtime errors.

The logic_error class (defined in header <stdexcept> ) is a base class for several standard exception classes that describes logic errors.

QuotientThrowRuntimeError.cpp

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

int quotient(int n1, int n2)
{
	if (n2 == 0)
	{
		throw runtime_error("Divisor cannot be zero!");
	}

	return n1 / n2;
}

int main()
{
	cout << "Enter two integers: ";
	int n1, n2;

	cin >> n1 >> n2;

	int result = 1;

	try
	{
		result = quotient(n1, n2);
		cout << n1 << " / " << n2 << " = " << result << endl;
	}
	catch(runtime_error &ex)
	{
		cout << ex.what() << endl;
		cout << result << endl; 
        // if result is defined in try block, it is best not to visit result!
	}

    return 0;
}

InvalidArgumentExceptionDemo.cpp

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

double getArea(double radius)
{
    if(radius < 0)
    {
        throw invalid_argument("Radius cannot be negative");
    }

    return radius * radius * 3.14159;
}

int main()
{
    cout << "Enter radius: ";
    double radius;
    cin >> radius;

    try
    {
        double result = getArea(radius);
        cout << "The area is " << result << endl;
    }
    catch(exception& ex)
    {
        cout << ex.what() << endl;  
    }

    return 0;
}

Custom Exception Classes#

You can define custom exception classes to model exceptions that cannot be adequately represented using C++ standard exception classes.
If we run into a problem that cannot be adequately described by the standard exception classes, we can create our own exception class. This class is just like any C++ class, but often it is desirable to derive it from exception or a derived class of exception so we can use the what() funtion.
The following is an example defining exception class TriangleException for the Triangle class.

Triangle.hpp

#ifndef TRIANGLE_H
#define TRIANGLE_H

#include <cmath>
#include "TriangleException.hpp"

class Triangle
{
public:
	Triangle()
	{
		side1 = side2 = side3 = 1;
	}

	Triangle(double side1, double side2, double side3)
	{
		if (!isValid(side1, side2, side3))
		{
			throw TriangleException(side1, side2, side3);
		}

		this->side1 = side1;
		this->side2 = side2;
		this->side3 = side3;
	}

	inline double getSide1() const
	{
		return side1;
	}

	inline double getSide2() const
	{
		return side2;
	}

	inline double getSide3() const
	{
		return side3;
	}

	inline void setSide1(double side1)
	{
		if (!isValid(side1, side2, side3))
		{
			throw TriangleException(side1, side2, side3);
		}

		this->side1 = side1;
	}

	inline void setSide2(double side2)
	{
		if (!isValid(side1, side2, side3))
		{
			throw TriangleException(side1, side2, side3);
		}

		this->side2 = side2;
	}

	inline void setSide3(double side3)
	{
		if (!isValid(side1, side2, side3))
		{
			throw TriangleException(side1, side2, side3);
		}

		this->side3 = side3;
	}

	inline double getArea() const
	{
		double p = (side1 + side2 + side3) / 2;
		return sqrt(p * (p - side1) * (p - side2) * (p - side3));
	}

	inline double getPerimeter() const
	{
		return (side1 + side2 + side3) / 2;
	}


private:
	double side1, side2, side3;
	inline bool isValid(double side1, double side2, double side3)
	{
		return ((side1 + side2) > side3) && ((side1 + side3) > side2) && ((side3 + side2) > side1);
	}
};

#endif // !TRIANGLE_H

TriangleException.hpp

#ifndef TRIANGLEEXCEPTION_H
#define TRIANGLEEXCEPTION_H

#include <stdexcept>
using namespace std;

class TriangleException : public logic_error // derived from logic_error class
{
public:
	TriangleException(double side1, double side2, double side3) : logic_error("Invalid Triangle")
	{
		this->side1 = side1;
		this->side2 = side2;
		this->side3 = side3;
	}

	inline double getSide1() const
	{
		return side1;
	}

	inline double getSide2() const
	{
		return side2;
	}

	inline double getSide3() const
	{
		return side3;
	}

private:
	double side1, side2, side3;
};

#endif // !TRIANGLEEXCEPTION_H

testTriangleException.cpp

#include <iostream>
#include "Triangle.hpp"
#include "TriangleException.hpp"

using namespace std;

int main()
{
	cout << "Enter three sides of a triangle: ";
	double s1, s2, s3;
	cin >> s1 >> s2 >> s3;

	try
	{
		Triangle t(s1, s2, s3);
		cout << t.getArea() << endl;
	}
	catch (TriangleException& ex)
	{
		cout << ex.what() << endl;
		cout << "Three sides of the invalid triangle are: " 
			<< ex.getSide1() << " " << ex.getSide2() << " " << ex.getSide3() << endl;
	}

	return 0;
}

A custom exception class is just like a regular class. Extending from a base class is not necessary, but it is a good practice to extend from the standard exception or a derived class of exception so your custom exception class can use the functions from the standard classes.

Multiple Catches#

A try-catch block may contain multiple catch clauses to deal with different exceptions thrown in the try clause.
One catch block can catch only one type of exception. C++ allows we to add mutiple catch block after a try block in order to catch multiple types of exceptions.
Note

• Various exception classes can be derived from a common base class. If a catch block catches exception objects of a base class, it can catch all the exception objects of the derived classes of that base class.
• The order in which exceptions are specified in catch blocks is important. A catch block for a base class type should appear after a catch block for a derived class type. Otherwise, the exception of a derived class is always caught by the catch block for the base class!

wrong order and correct order

// wrong order
try
{
    // something
}
catch(logic_error& ex)
{
    //
}
catch(TriangleException& ex)
{
    //
}

// correct order
try
{
    // something
}
catch(TriangleException& ex)
{
    //
}
catch(logic_error& ex)
{
    //
}

You may use an ellipsis (...) as the parameter of catch, which will catch any exception no matter what the type of the exception that was thrown. This can be used as a default handler that catches all exceptions not caught by other handlers if it is specified last.

default handler demo

try
{
    // Execute some code here
}
catch (Exception1& ex1) 
{
    cout << "Handle Exception1" << endl;
}
catch (Exception2& ex2) 
{
    cout << "Handle Exception2" << endl;
}
catch (...)
{
    cout << "Handle all other exceptions" << endl;
}

Exception Propagation#

An exception is thrown through a chain of calling functions until it is caught or it reaches to the main function.

try-catch block

try
{
    // Statements that may throw exceptions
}
catch (Exception1& ex1) 
{
    // handler for exception1;
}
catch (Exception2& ex2) 
{ 
    // handler for exception2;
}
...
catch (ExceptionN& exN) 
{
    // handler for exceptionN;
}

• If no exceptions arise during the execution of the try block, the catch block are skipped.
• If one of the statements inside the try block throws an exception, C++ skips the remaining statements in the try block and starts the process of finding the code to handle the exception.
  • Each catch block is examined in trun, from first to last, to see whether the type of the exception object is an instance of the exception class in the catch block.
  • If one catch block is matched, the code in the catch block is executed.
  • If no handle is found, C++ exits this function, passes the exception to the function that invoked the function, and continues the same process to find a handler.
  • If no handler is found in the chain of functions being invoked, the program prints an error message on the console and terminates.

• If the exception type is Exception3, it is caught by the catch block for handling exception ex3 in function2. statement5 is skipped, and statement6 is executed.
• If the exception type is Exception2, function2 is aborted, the control is returned to function1, and the exception is caught by the catch block for handling exception ex2 in function1. statement3 is skipped, and statement4 is executed.
• If the exception type is Exception1, function1 is aborted, the control is returned to the main function, and the exception is caught by the catch block for handling exception ex1 in the main function. statement1 is skipped, and statement2 is executed.
• If the exception is not caught in function2, function1, and main, the program terminates. statement1 and statement2 are not executed.

Rethrowing Exceptions#

After an exception is caught, it can be rethrown to the caller of the function.

syntax of rethrowing exceptions

try
{
    // statements;
}
catch (TheException& ex) 
{
    // perform operations before exits;
    throw;
}

The statement throw rethrows the exception so that other handlers get a chance to process it.

rethrow exceptions demo

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

int f1()
{
    try
    {
        throw runtime_error("Exception in f1");
    }
    catch(exception& ex)
    {
        cout << "Exception caught in function f1" << endl;
        cout << ex.what() << endl;
        throw;
    }
}

int main()
{
    try
    {
        f1();
    }
    catch(exception& ex)
    {
        cout << "Exception caught in function main" << endl;
        cout << ex.what() << endl;
    }

    return 0;
}

Exception Specification#

You can declare potential exceptions a function may throw in the function header.
An exception specification, also known as throw list, lists exceptions that a function can throw. So far, we have seen the function defined without a throw list. In this case, the function can throw any exception. So, it is tempting to omit exception specification. However, this is not a good practice.

A function should give warning of any exceptions it might throw. So that programmers can write robust program to deal with these potential exceptions in a try-catch block.

syntax for exception specification

returnType functionName(parameterList) throw (exceptionList)

exception specification demo

Triangle(double side1, double side2, double side3) 
    throw (NonPositiveSideException, TriangleException)
{
    check(side1); // throws NonPositiveSideException
    check(side2);
    check(side3);

    if(!isValid(side1, side2, side3))
    {
        throw TriangleException(side1, side2, side3);
    }

    this->side1 = side1;
    this->side2 = side2;
    this->side3 = side3;
}

• If a function attempts to throw an exception. A standard C++ function unexpected is invoked, which normally terminates the program.
• If a function specifies bad_exception in its throw list, the function will throw a bad_exception if an unspecified exception is throw from the function.

When to use Exceptions#

Use exceptions for exceptional circumstances, not for simple logic errors that can be caught easily using an if statement.
Exception handling separates error-handling code from normal programming tasks, thus making programs easier to read and to modify. Be aware, however, that exception handling usually requires more time and resources, because it requires instantiating a new exception object, rolling back the call stack, and propagating the exception through the chain of functions invoked to search for the handler.

Use exception handling ✔️	Do not using exception handling ❌
We want the exception to be processed by its caller	We can handle the exception in the function where it occurs
Common exceptions that may occur in multiple classes	Simple errors that may occur in individual functions
Dealing with unexpected error conditions	Dealing with simple, expected situations

A general paradigm for exception handling is that yo

u declare to throw an exception in a function as shown in (a) below, and use the function in a try-catch block as shown in (b).

---

--------------------The End------------------

本文采用CC-BY-SA-3.0协议，转载请注明出处
作者: 核子