cmc/seminars/2.md

Про оптимизации

A obj = A(10); // A(const A&)
obj1 = obj; // A(A&)

при отключении оптимизации будет:

• преобразования
• копирования
• деструктор

На экзе во всех задачах вероятно отключена оптимизация

A f(...) {
    A local;
    return local;
}

будет создаваться 2 переменные.

Перегрузка (продолжение)

Приведение типов

operator double() {
    return re;
}
double x = 3.1, y;
y = C1 + x; // !error - не понятно, к какому типу
y = double(C1) + x == C1 + C(x);

Ввод/вывод

friend ostream & operator<<(ostream &os, C&a) {
    os << "re=" << a.re << ...;
    return os;
}

int main() {
    C obj(1,2);
    cout << obj; // ostream and class
    return 0;
}

Перегрузка вызова функции

struct Pred {
    bool operator()(int v) {
        return v < 10;
    }
};

void f(int *mas, int n, Pred(c)) {
    for (int i = 0; i < n; ++i) {
        if (c(mas[i])) {
            mas[i] *= 2;
        }
    }
}

---

Перегрузка функций

Алгоритм для поиска наиболее подходящей функции для вызова

1. по количеству параметров
2. отбросить недопустимые преобразования
3. точные совпадения (на typedef):
   1. T <-> T&
   2. T[] <-> *T
   3. T -> const T
4. можно расширить тип (например к инт):
   1. unsigned char
   2. unsigned short
   3. short and etc
   4. float -> double (нет лонг дабл)
5. стандартные преобразования
   • Любой числовой приводится к любому числовому типу
   • Любой указатель приводится к указателю на void
   • 0 к любому указателю или любому числовому
6. пользовательсткие преобразования

---

const int ci = 1;
void f(int y) {...}

f(ci); // всё ок

---

алгоритм (фактически):

• отбрасываем неподходящие
• по каждому параметру берём множество подходящих функций
• смотрим персечение

struct A {
    operator int() { return 1; }
    void f(double d, char c); // 1
    void f(double d, int j); // 2
    void f(A a, const char *p); // 3
    void f(int i, const char *p); // 4
};

int main() {
    A a;

    f(a, 0); // 3 & 2 => 0
    f(a, 'a'); // 12 & 1 => 1
    f('a', 0); // 4 & 2 => 0
}

Статические члены класса

class A {
    int a;
    static int b;
public:
    A(int x) : a(x) { }
    static void f() {
        cout << b;
    }
};

int main() {
    int A::b = 77;
    A::f();
    return 0;
}

требования:

• работа только с статик полями
• вызывать только статик функции
• нельзя как const или virtual объявить (void f const { } // может менять статик и mutable поля)

class A {
    static int x;
    int y;
public:
    int f(int x) const {};
};

int main() {
    const A a;
    a.x = 3;
    cout << a.y << a.x << a.f(1);
}

---

struct A {
    int n;
    int k;
    A (A &a) { n = a.n; }
    int f() { return k; }
    A (int a) { n = a; }
};

int main() {
    A a = A(1), b;
    cout << A::f() << " " << a.k << a.n << endl; // 5 53
}

struct A {
    int n;
    static int k;
    A (const A &a) { n = a.n; }
    static int f() { return k; }
    A (int a = 3) { n = a; }
};

int A::k = 5;

int main() {
    A a = A(1), b;
    cout << A::f() << " " << a.k << b.n << endl; // 5 53
}