 |
Абстрактные типы данных (АТД). Классы.
|
|
|
|
Конструкторы и деструкторы
1.1. Ошибочны 2, 3 и 4 описания объектов в функции f(). Исправить можно так:
class A {
int a, b;
public:
A (const A & x) {
a = x.a;
b = x.b;
cout << 1;
}
A (int a = 0, int b = o) {
this -> a = a;
b = a;
cout << 2;
}
};
На печать будет выдано:
без оптимизации: 2221211
с оптимизацией: 22221
1.2. A (int a = 0, int b = 1) {…}
1.3. a) Есть ошибки в функции main ():
X a; - нет конструктора умолчания
X b(1); - - неоднозначность
На экран будет выдано: 24233
b) Есть ошибки в функции main ():
X a; - - неоднозначность
На экран будет выдано: 22323 или
2232 – для оптимизируещего компилятора.
1.4.
class A {
int x;
public:
A (int y) { x = y; }
int get () { return x; }
int operator *= (int y) { return x = x*y; }
};
1.5.
class B {
int x;
public:
B () { x = 10; }
B (const B & y) { x = y.x + 10; }
int get () { return x; }
};
1.6.
class C {
int x;
public:
C (int y) { x = 2 * y; }
int get () { return x; }
C operator + (C c) {
C t (x + c.x);
return t;
}
};
1.7.
class A {
int x;
public:
A (int y = 7) { x = y; }
int get () { return x; }
int operator *= (int y) { return x *= y; }
};
1.8.
class B {
int x, y;
public:
B (int a, int b = 5) { x = a; y = b; }
int get () { return x + y; }
B & operator =+ (B & b){
x += b.x;
y += b.y;
return * this;}
};
1.9.
class C {
int x;
public:
explicit C (int y) { x = 2 * y; }
int get () { return x; }
C operator + (C c) {
C t (x + c.x);
return t;
}
};
1.10.
sun
venus 20
venus 400
moon
earth 420
venus 1000
moon
moon
1429 420
moon
moon
1.11.
owl
sheep 3
sheep 7
wolf
horse 42
sheep 1
wolf
wolf
42 126
wolf
wolf
1.12.
fist
lance 30
lance 700
pistole
dagger 730
lance 1000
pistole
pistole
1735 730
pistole
pistole
1.13.
Необходимо убрать в приватную часть конструктор копирования, например:
struct mystr {
int a, b;
private:
mystr(const mystr & s) {}
};
1.14. Необходимо, чтобы для этой структуры отсутствовал конструктор умолчания. Достаточно описать структуру, содержащую конструктор с одним или более параметром и не содержащую конструктор без параметров, например:
struct smartstr {
|
|
|
int a, b;
smartstr(int x): a(x), b(x) {}
};
1.15.
a) A(), B(), C(), A(const A&), A(), B(), D(),
~D(), ~B(), ~A(), ~A(), ~C(), ~B(), ~A()
b) A(), B(), A(const A&), D(), A(), B(), C(),
~C(), ~B(), ~A(), ~D(), ~A(), ~B(), ~A()
c) A(), B(), C(), A(), B(), C(), B(const B&), D(),
~D(), ~B(), ~C(), ~B(), ~A(), ~C(), ~B(), ~A()
1.16. Cons Copy Cons Des Copy Des Des 1 Des
1.17. Cons Cons Des Copy Des 3 Des
1.18. Cons Copy Cons Des Des 1 Des
1.19. 1) перед деструктором базового класса добавить virtual.
2) добавить либо В (float a = 0), либо D (): B (0) {...}
1.20. 1) перед деструктором базового класса добавить virtual.
2) добавить В (int a = 0) {...}
1.21. 1) перед деструктором базового класса добавить virtual.
2) добавить D (int d = 0) {...}
1.22.
a) Параметры по умолчанию должны представлять собой константы време ни компиляции, так что последний параметр функции f описан с ошибкой. Других ошибок нет.
b) если некоторый параметр функции допускает умолчание, то все остальные параметры справа от него тоже должны допускать умолчание. В данном случае это правило нарушено для параметра t.
c) Параметры по умолчанию должны представлять собой константы времени компиляции, так что последний параметр функции f описан с ошибкой. Других ошибок нет; в частности, описание второго параметра (t) ошибки не содержит.
Перегрузка операций. Перегрузка функций
2.1. Необходимо убрать в приватную часть операцию присваивания от аргумента типа
<<ссылка на Cls>>, например:
class Cls {
void operator= (const Cls &) {}
public:
Cls () {}
};
2.2
a) void g (double a, int b = 0);
void g (int, const char * = 0);
Возможны варианты с double, char...
b) void f (const char * a = 0);
void f (int a, int b = 0);
Возможны варианты с char...
c) void f (const char *, int);
void f (int, const char *);
d) void f (int, const char *); либо void f (X, const char *);
void f (const char *);
e) void f (double d = 0, const char * s = 0);
void f (const char *); либо void f (const char *, int i = 0);
2.3.
a) f(); // f(int), (a) на этапе выбора функций,
// подходящих по кол-ву параметров;
f(s); // f(int), (б) целочисленное расширение
f(f); // f(double),(б) вещественное расширение
f(b); // f(int), (б) целочисленное расширение
|
|
|
f(A); // f(int), (б) целочисленное расширение
b) f(); // (а) неоднозначность определения числа параметров
f(4); // (в) неоднозначность при стандартном преобразовании
f(f); // f(double), (б) вещественное расширение
f(d); // f(double), (а) точное отождествление
f(ld);// f(long double),(а) точное отождествление
c) f(s); // f(int), (б) целочисленное расширение
f(i); // f(int), (а) точное отождествление
f(b); // f(int), (б) целочисленное расширение
f(f); // (в) неоднозначность при стандартном преобразовании
f(d); // (в) неоднозначность при стандартном преобразовании
Наследование. Видимость и доступность имен
3.1.
a) void B::g() {
f(); // ошибка, эта f не видна
f(1); // B::f(1);
f(5, 1); // ошибка эта f не видна
x = 2; // ошибка, так как int x private в базовом классе
}
int main () {
B b; // A(), B()
f(5); //ошибка, эта f не видна
f(‘+’, 6); //::f(‘+’, 6);
b = ret (b, b); // A(const A &), B(const B &)
return 0;
}
Будут вызваны следующие конструкторы и деструкторы:
A(), B(), A(const A &), B(const B &), ~B(), ~A(), ~B(), ~A().
b) void B::g() {
f(1.2); // B::f
f(); // ошибка эта f не видна
a = 2; // A::a = 2
}
int main () {
B d;
f(); //ошибка
f(6); //::f
empty (d, d);
return 0;
}
Будут вызваны следующие конструкторы и деструкторы:
A(), B(), A(const A &), B(const B &), ~B(), ~A(), ~B(), ~A().
c) void B::g() {
f(); // ошибка, эта f не видна
f(0); // B::f(0);
f(5.3, 1); // ошибка эта f не видна
x = 1; // ошибка, так как int x private в базовом классе
}
int main () {
B b;
f(2); // ошибка, эта f не видна
f(3, 'a'); //::f(3, a);
return 0;
}
Будут вызваны следующие конструкторы и деструкторы: A(), B(), ~B(), ~A()
d) void B::g() {
f(r); // B::f
f(); // ошибка эта f не видна
a = 2; // BBase::a = 2
}
int main () {
B d;
f(); //ошибка, неоднозначный выбор f
f(6); //::f
return 0;
}
Будут вызваны следующие конструкторы и деструкторы:
BBase(), B(), ~B(), ~BBase()
e) void B::g() {
f(); // ошибка, эта f не видна
f(1); // ошибка, эта f не видна
f(-1, 1); // ошибка, неоднозначный выбор f
x = 2; // ошибка, так как int x private в базовом классе
}
int main () {
B b;
f(5); //::f(5);
f(+, 6); // ошибка, эта f не видна
return 0;
}
Будут вызваны следующие конструкторы и деструкторы: T(), B(), ~B(), ~T()
3.2.
а) C::x = A:: f ();
C::f (3);
C::x = :: f (4, 5);
C::x = 6;
c. A:: f ();
c.C::f (7);
::x =::f (‘8’, 9);
Подчеркнуты исправляющие (обязательные) расширения.
Будут вызваны следующие конструкторы и деструкторы:
A(), B(), C(), B(const B &), A(const A &), ~A(), ~B(), ~C(), ~B(), ~A()
b) x = A:: f ();
x = B:: f (5);
x = B:: f (6, 6);
x = B:: f (5);
x = a. A:: f ();
|
|
|
x = a.B:: f (7);
return a.B::g (& a, & a);
Подчеркнуты исправляющие (обязательные) расширения.
Будут вызваны следующие конструкторы и деструкторы:
A(), B(), A(), B(), A(const A &), C(), ~C(), ~A(), ~B(), ~A(), ~B(), ~A()
c) C::x = A:: f ();
C::f (3);
C::x = :: f (4, 5);
C::x = 6;
//main()
c. A:: f ();
c.C::f (7);
::x =::f (‘8’, 9);
Подчеркнуты исправляющие (обязательные) расширения.
Будут вызваны следующие конструкторы и деструкторы:
A(), B(), C(), B(const B &), A(const A &), ~A(), ~B(), ~C(), ~B(), ~A().
d) x = A:: f(); // A::f()
x = B:: f(5); // B::f(5)
x = B:: f(6, 6); // B::f(6, 6)
x = B:: f(5); // B::f(5)
//main()
x = a. A:: f(); // A::f()
x = a.B:: f(7); // B::f(7)
return a.B::g(& a, & a);
Подчеркнуты исправляющие (обязательные) расширения.
Будут вызваны следующие конструкторы и деструкторы:
A(), B(), A(const A &), C(), ~C(), ~A(), ~B(), ~A()
e) Ошибочны 2 оператора, которые можно исправить:
x = c. A:: f ();
x = c. A:: f (x); // x = c. B:: f (x);
Будут вызваны следующие конструкторы и деструкторы:
A(), B(), A(), B(), C(), A(const A&), A(), B(), D(),
~D(), ~B(), ~A(), ~A(), ~C(), ~B(), ~A(), ~B(), ~A()
f) Ошибочны 2 оператора, которые можно исправить:
x = c. A:: f ();
x = c. A:: f (x);
Будут вызваны следующие конструкторы и деструкторы:
A(), B(), A(), B(), C(), A(), B(), A(const A&), D(),
~D(), ~A(), ~B(), ~A(), ~C(), ~B(), ~A(), ~B(), ~A()
3.3. Требуется уточнить обращения к полю “m” с помощью операций разрешения области видимости “::” для класса “B” либо для “С”, например, так:
fA. C:: m = 0;
return *((* f).e = & fA. C:: m);
Либо во всех описаниях производных классов вставить указание виртуального наследования (всего 4 поправки, из которых исправления в классах “B” и “С” при таком подходе – обязательны):
class B: virtual public A { public: int * p; };
class C: virtual public A { public: int * c; };
3.4.
1. Необходимо заменить вид наследования класса “S” на открытый, чтобы поле
“s” стало доступным в классе “U”:
class T: public S {
public:
int t;
void tp (int ti) { t = ti; s = ti; }
};
2. Необходимо дополнительно заменить вид наследования класса “T” на открытый, чтобы стали возможными преобразования указателей в процедуре “g()”:
class U: public T {
public:
int u;
void up (int ui) { u = ui; t = ti; s = ti; }
};
3. Открытости наследования можно добиться, заменяя в наследующем классе слово “ class ” словом “ struct ”.
3.5.
1. Чтобы преобразование из класса “W” в функции “h()” в класс “Z” стало воз- можным, это преобразование надо исправить:
|
|
|
pz = (Z *)(X *) (new W);
2. Дополнительно необходимо сделать открытым вид наследования класса “W” классом “X” и класса “X” классом “Z”:
class X: public W {... }; class Z: public X,Y {... };
3. Необходимо уточнить область видимости поля “w” в теле функции “h()”:
(*pz). X:: w=& hi;
4. Открытости наследования можно добиться, заменяя в наследующем классе слово “ class ” словом “ struct ”.
|
|
|
