# midterm example discussion
## Q2: explain all compile-time errors and fix them
**The incorrect codes** / The correct codes
```cpp=
#include <iostream>
class Date {
public:
int Date(int y, int m = 0, int d); // v -1
Date(Date src) { // -1
setDate(src.year, src.month, src.day);
counter++;
}
void ~Date(); // v
void setDate(int y, int m, int d) const { // v
year = y;
month = m;
day = d;
}
void getDate(int &y, int &m, const int &d) { // v
y = year; m = month; d = day; // v
}
static int getCount() {
print(*this); // v -1
return counter;
}
friend print(const Date &date); // v
private:
int ndays;
static int counter = 0; // v
int year;
int month;
int day;
};
void print(const Date &d) { // v
cout << d->year << d->month << d->day; // v
}
int print(const Date &d, int cnt = 0) { // v
cout << d.year << d.month << d.day << cnt; // -1
return getCount(); // v
}
int main() {
int y = 2019, m = 11, d = 22;
Date day1(2019, 11, 11);
Date *day2 = new Date(y, m, d);
Date days[10];
std::cout << day1.counter; // -1
day2->setDate(&y, &m, &d); // -1
print(days[1]);
delete [] days;
}
// guessing (v if true else x)
/*
L4: constructor should have no returning type.
L4: constructor is not implemented yet.
Date(int y, int m = 0, int d):
year(y), month(m), day(d) {}
L4: constructor should have no returning type.
L9: destructor is not implemented yet.
~Date(){}
L10: modifier method should not be marked as const (it implies read-only method)
void setDate(int y, int m, int d) {
L16: the const paramter d is not modifiable.
void getDate(int &y, int &m, int &d) {
y = year; m = month; d = day;
}
L19: *this is unavailable, the function is static.
static int getCount() {
return counter;
}
L??: cout is not defined.
cout --> std::cout
L22: friend function print has no returning type
L30: unambiguity
L33: unambiguity
friend void print(const Date &date);
friend int print(const Date &date, int cnt);
// ...
void print(const Date &d) {
int print(const Date &d, int cnt) {
L25: non const static data member cannot initialize in class.
static inline int counter = 0;
L31: const Date& is not deferenceable (non-pointer type).
cout << d.year << d.month << d.day;
L35: getCount is not defined
return Date::getCount();
L42: no member names counter in day1. (X)
cout << Date::counter;
*/
// missing (-1)
/*
L5: invalid constructor; you probably meant 'Date (const Date&)'
L4: default argument missing for parameter 3 of 'Date::Date(int, int, int)'
Date(int y, int m = 0, int d = 0);
L19: 'print' was not declared in this scope
friend print(const Date &date); // v
static int getCount() {
print(*this); // v -1
return counter;
}
L34: error: 'int Date::year' is private within this context
L42: counter is private member
static int counter = 0;
private:
L43: invalid conversion from 'int*' to 'int'
day2->setDate(y, m, d);
*/
```
The incorrect codes / **The correct codes**
```cpp=
#include <iostream>
class Date {
public:
Date(){} //
Date(int y, int m, int d): year(y), month(m), day(d) {} //
Date(const Date &src) { //
setDate(src.year, src.month, src.day);
counter++;
}
~Date(){} //
void setDate(int y, int m, int d) { //
year = y;
month = m;
day = d;
}
void getDate(int &y, int &m, int &d) { //
y = year; m = month; d = day;
}
friend void print(const Date &date); //
friend int print(const Date &date, int cnt); //
static int getCount() {
//
return counter;
}
static inline int counter = 0; //
private:
int ndays;
int year;
int month;
int day;
};
void print(const Date &d) {
std::cout << d.year << d.month << d.day; //
}
int print(const Date &d, int cnt) { //
std::cout << d.year << d.month << d.day << cnt;
return Date::getCount(); //
}
int main() {
int y = 2019, m = 11, d = 22;
Date day1(2019, 11, 11);
Date *day2 = new Date(y, m, d);
Date days[10];
std::cout << day1.counter;
day2->setDate(y, m, d); //
print(days[1]);
delete [] days;
}
```
## Q3: callers (1-16) and callees (A-H)
callees (A-H)
```cpp=
A: TimeOfDate(int h=0, int m=0);
B: TimeOfDate(float i);
C: TimeOfDate(char *str);
D: TimeOfDate(const TimeOfDate &src);
E: ~TimeOfDate();
F: operator int() const;
G: operator char *() const;
H: TimeOfDate & operator=(const TimeOfDate &src);
```
callers (1-16)
```cpp=
TimeOfDate t1;
static TimeOfDate t2(“12:30”);
TimeOfDate &foo(TimeOfDate t3) {
TimeOfDate t4=t3;
TimeOfDate *t5 = new TimeOfDate[2];
return t4;
}
int main() {
TimeOfDate *t6 = new TimeOfDate(3.5);
TimeOfDate t7(12,30);
foo(*t6) = t2;
delete t6;
int i = t2;
cout << (char *)t1 << i;
return 0;
}
```
guessing answer
```=
A
C
D
D
A
E
B
A
H
E
F
G
E
```
The memory management problems
```=
Line 3, 6: returning local reference
Line 5: not free'd
```
## Q4: Common Compile-Time Errors
a. guessing answer
```cpp=
B::B(int v): a(v) {}
```
b.
```cpp=
class B, C;
class A {
public:
A(int u) {x=u;}
int f();
private:
friend B;
int g() const;
int x;
};
class B {
public:
B(int v=0);
int f();
private:
A a;
};
class C {
public:
static int g();
B *operator->();
private:
static int x; int y;
B *pb;
};
B b;
C c;
```
guessing answer
```cpp=
int x1 = c.x; // C::x is private member, it should be public
int x2 = b.f(); // legal, it returns an int type directly
int x3 = C::g(); // legal, it returns an int type by calling the static method
int y = b.a.f(); // a is a private member of b, it should be public
int z = c->f(); // legal, it returns an int type by calling B::f()
int A::g() const { return f(); } // A::f() is non-const method, it cannot be called by const method A::g()
void B::f() { a.x = 1; } // legal, B which is a friend of A assigns 1 to the private member x
int C::g() { return y = x; } // C::g() is a static method of A, which has no implicit this pointer holding y
```
## Q5: Operator Overloading
```cpp=
#include <iostream>
using namespace std; // don't forget this line
class Nint {
public:
Nint(int v=0) { x=v; }
Nint& operator=(int i) { x=i; return(*this);}
Nint operator+(const Nint &o) { return( x + o.x); }
friend ostream &operator<<( ostream &, const Nint& );
private:
int x;
};
ostream &operator<<(ostream &o, const Nint &v) {
o << v.x;
return(o);
}
int main(void) {
Nint a=3,b=7,c,d,e;
cout << "A is " << a << endl;
cout << "B is " << b << endl;
c = a + b;
cout << "C is " << c << endl;
d = a + 7 + c;
cout << "D is " << d << endl;
cout << "E is " << e << endl;
}
```
guessing answer
a.
```=
A is 3
B is 7
C is 10
D is 20
E is 0
```
b. if the returning type is ostream, will it compile?
```
In Line 15, the copy constructor of ostream is called,
which is deleted. It won't compile.
```
c. If you don’t have the global operator overloading of operator<< (lines 11-14), is it possible to add another operator overloading of Nint to make the program compile?
```cpp=
It is impossible to add only one operator to compile,
the crucial function is: operator<<(ostream& o, Type var).
The following casting operator is used for operator<<(ostream& o, const char* var);
Nint::operator const char*() const {
return make_unique<string>(to_string(x))->c_str();
}
However, the implicit casting will cause the conflicts
between operator+(const char*, int) and Nint::operator+(const Nint&).
So it needs two operators to make it compile:
Nint Nint::operator+(int i) {
return(x + i);
}
Nint::operator const char*() const {
return make_unique<string>(to_string(x))->c_str();
}
```
### Q6: OOD
```cpp=
#include <cmath>
class Pokemon {
int attack;
int defense;
int stamina;
float CPM;
public:
Pokemon(int attack, int defense, int stamina, float CPM):
attack(attack), defense(defense), stamina(stamina), CPM(CPM) {}
float CP() const {
return (attack * pow(defense, 0.5) *
pow(stamina, 0.5) * pow(CPM, 2)) / 10;
}
bool operator==(const Pokemon &_) const {
return attack == _.attack &&
defense == _.defense &&
stamina == _.stamina &&
CPM == _.CPM;
}
bool operator!=(const Pokemon &_) const {
return !(*this == _);
}
bool operator>(const Pokemon &_) const {
return CP() > _.CP();
}
bool operator<(const Pokemon &_) const {
return CP() < _.CP();
}
};
```
Sign in with Wallet
Connect another wallet