 |
Перегрузка операций. Перегрузка функций
|
|
|
|
2.1. Даны описание класса и функции:
class Cls {
int i;
public:
Cls() { i = 1; }
};
void f(Cls * p, Cls * q) {
*p = *q;
}
Дополните описание класса Cls (не изменяя описание функции f)
так, чтобы только описание f стало ошибочным.
2.2. Описать прототипы двух перегруженных функций f из некоторой области видимости, для которых будут верны следующие обращения к ним:
a) f (1);
f (‘+’, ‘+’);
f (2.3);
f (3, “str”);
b) f ();
f (“abc”);
f (2);
f (‘+’, 3);
c) f (0, 1);
f (1, 0);
f (0, "m");
f ("n", 0);
d) f ("p"); // где struct X {
f (x, 0); // X(int);
f (0, 0); // operator int ();
f (x, "q"); // } x;
f (1, "r");
e) f (1000000000000);
f (1);
f ();
f (0, 0);
f ("t");
f (1, "u");
2.3. Для каждого вызова перегруженной функции с одним параметром укажите, какая функция и на каком шаге алгоритма будет выбрана.
а) int f(int a = 0) { return a; }
int f(double a) { return a; }
int main() {
short int s;
int i;
bool b;
enum e {A, B, C};
float f1 = 1.0f;
f();
f(s);
f(f1);
f(b);
f(A);
}
b) int f(double a = 1.0){ return a;}
int f(long double a = 5.0){ return a;}
int main() {
float f1 = 1.0f;
double d = 2.0;
long double ld = 3.0l;
f();
f(4);
f(f1);
f(d);
f(ld);
}
c) int f(int a = 1){ return a;}
int f(long double a = 5.0){ return a;}
int main () {
short int s;
int i;
bool b;
float f1 = 1.0f;
double d = 2.0;
f(s);
f(i);
f(b);
f(f1);
f(d);
}
Наследование. Видимость и доступность имен
3.1. Если есть ошибки в реализации функций B::g () и main (), объясните, в чем они заключаются.
Для всех правильных операторов этих функций с помощью операции разрешения области видимости «::» укажите, из какой области видимости выбираются участвующие в их записи имена.
Какие конструкторы и деструкторы и в каком порядке будут вызываться при работе данной программы?
a) int x = 0;
void f (int a, int b){x = a+b;}
class A {
int x;
public:
void f (){x = 2;}
};
class B: public A {
public:
void f (int a){::x = a;}
void g ();
};
void B::g() {
|
|
|
f();
f(1);
f(5, 1);
x = 2;
}
B ret (B & x, B & y) {
return x;
}
int main () {
B b;
f(5);
f(‘+’, 6);
b = ret (b, b);
return 0;
}
b) double a = 0;
void f (double x){a = x;}
struct A {
double a;
void f (){a = 2;}
};
class B: A {
public:
void f (int a){::a = a;}
void g ();
};
void B::g() {
f(1.2);
f();
a = 2;
}
void empty (B & a, B b) { }
int main () {
B d;
f();
f(6);
empty (d, d);
return 0;
}
c) int x = 0;
void f(int a, int b) { x = a+b; }
class A {
int x;
public:
void f() { x = 2; }
void f(char a1, char b1) { x = a1-b1; }
};
class B: public A {
public:
void f(int a) {::x = a; }
void g () {
f();
f(0);
f(5.3, 1);
x = 1;
}
};
int main () {
B b;
f(2);
f(3, 'a');
return 0;
}
d) double a = 0;
void f(double x = 2) {
a = x;
}
void f() {
a = 1;
}
struct BBase {
double a;
void f(){
a = 2;
}
};
class B: BBase {
public:
void f(int a) {::a = a; }
void g() {
f('r');
f();
a = 2;
}
};
int main () {
B d;
f();
f(6);
return 0;
}
e) float y = 0;
void f(float a) {
y = a;
}
class T {
int y;
public:
void f() {
y = 2;
}
};
class B: public T {
public:
void f(float n, float m) {::y = n * m; }
void f(char c1, char c2) {::y = c1 + c2; }
void g () {
f();
f(1);
f(-1, 1);
y = 2;
}
};
int main () {
B b;
f(5);
f('+', 6);
return 0;
}
3.2. Если есть ошибки в реализации методов заданных классов и функции main (), исправьте их, используя операцию разрешения области видимости " :: ".
Какие конструкторы и деструкторы и в каком порядке будут вызываться при работе данной программы?
a) int x = 0;
int f (int a, int b) { return x = a + b; }
class A {
int x;
public:
A (int n = 1) { x = n; }
int f() { return::x = x; }
};
class B {
int x;
public:
B (int n = 2) { x = n; }
};
class C: public A, public B {
int x;
public:
int f(int a) { return::x = x; }
void g ();
};
void C::g() {
x = f ();
f (3);
x = f (4, 5);
x = 6;
}
int main () {
C c;
B b = c;
A a = с;
c.f ();
c.f (7);
x = f (‘8’, 9);
return -1;
}
b) int x = 0;
int f() { return x = 1; }
class A {
int x;
public:
A(int n = 2) { x = n; }
int f() { return x = 3; }
int f(int a, int b) { return x = a % b; }
};
class B: public A {
int x;
public:
int f(int a) { return x = a; }
int f(int a, int b) { return x = a + b; }
int g(A * a, B * b);
};
int B::g (A * pa, B * pb) {
x = f ();
x = f (5)
x = f (6, 6);
x = A::f (5);
return -1;
}
int main () {
B a;
class C {
B b;
A a;
public:
C(): b(), a (b) { }
};
C c;
x = a.f ();
x = a.f (7);
return a.g (& a, & a);
}
c) int x = 0;
int f (int a, int b) { return x = a + b; }
class A {
int x;
public:
A(int n = 1) { x = n; }
int f() { return::x = x; }
};
class B {
int x;
public:
B (int n = 2) { x = n; }
|
|
|
};
class C: public A, public B {
int x;
public:
int f(int a) { return::x = x; }
void g ();
};
void C::g() {
x = f ();
f (3);
x = f (4, 5);
x = 6;
}
int main () {
C c;
B b;
A a;
c.f();
c.f(7);
x = f(‘8’, 9);
return -1;
}
d) int x = 0;
int f() { return x = 1; }
class A {
int x;
public:
A(int n = 2) { x = n; }
int f() { return x = 3; }
int f(int a, int b) { return x = a % b; }
};
class B: public A {
int x;
public:
int f(int a) { return x = a; }
int f (int a, int b) { return x = a + b; }
int g (A * a, B * b);
};
int B::g (A * pa, B * pb) {
x = f();
x = f(5);
x = f(6, 6);
x = A::f(5);
return -1;
}
int main () {
B a;
x = a.f();
x = a.f(7);
class C {
A a1;
public:
C(): a1(b) {}
};
C c;
return a.g(& a, & a);
}
e) int x = 4;
class A {
int x;
public:
A(int n = 1);
int f(int a = 0, int b = 0);
};
class B: public A {
public:
int x;
B(int n = 2);
int f(int a);
};
class C: public B {
int x;
public:
C(int n = 3);
int f(int a, int b);
int g(A * p);
};
int main () {
A * p;
B b;
C c;
A a = c;
struct D {
B b;
D(): b(5) {}
} d;
p = & b;
x = c.g(& c);
x = c.f();
x = c.f(x);
x = c.f(x, 1);
x = p -> f();
x = p -> f(x);
x = p -> f(x, 1);
return 1;
}
f) int x = 4;
class A {
int x;
public:
A(int n = 3);
int f(int a = 0, int b = 0);
};
class B: public A {
int x;
public:
B(int n = 1);
int f(int a = 0);
};
class C: public B {
int x;
public:
C(int n = 2);
int f(int a, int b);
int g(A * p);
};
int main () {
A * p;
B b;
C c;
class D {
B b;
A a;
public:
D(): a(b) {}
} d;
p = & b;
x = c.g(& b);
x = c.f();
x = c.f(x);
x = c.f(x, 1);
x = p -> f();
x = p -> f(x);
x = p -> f(x, 1);
return 2;
}
3.3. Если есть ошибки в следующем фрагменте, то в чем они заключаются? Исправьте ошибки, ничего не удаляя, добавив в общей сложности не более 14 символов.
class A {
public:
int * n;
int m;
};
class B: public A {
public:
int * p;
};
class C: public A {
public:
int * c;
};
class D: public B, public C {
public:
int * e;
};
int main () {
D fA, * f = new D;
fA.m =0;
return *((* f).e = & fA.m);
}
3.4. Если есть ошибки в следующем фрагменте, то в чем они заключаются? Исправьте ошибки, ничего не удаляя, добавив в общей сложности не более 12 символов.
class S {
public:
int s;
void sp(int si) { s = si; }
};
class T: S {
public:
int t;
void tp(int ti) { t = ti; s = ti; }
};
class U: T {
public:
int u;
void up(int ui) { u = ui; t = ui; s = ui; }
};
void g() {
U * pu = new U;
T * pt = pu;
S * ps = pu;
}
3.5. Если есть ошибки в следующем фрагменте, то в чем они заключаются? Исправьте ошибки, ничего не удаляя, добавив в общей сложности не более 29 символов.
class W {
public:
int * w;
void wf (int * wp) { w = wp; }
};
class X: W {
public:
int * x;
void xf (int * xp) { x = xp; w = xp; }
};
class Y: W {
public:
int * y;
void yf (int * yp) { y = yp; w = yp; }
};
class Z: X, Y {
public:
int * z;
void zf (int * zp) { z = zp; x = zp; y = zp; }
};
void h () {
int hi;
W * pw;
X * px;
Y * py;
Z * pz;
pz = new W;
(*pz).w = & hi;
pz -> xf ((*pz).X::w);
}
|
|
|
