13.x – Резюме к главе 13 и небольшой тест

1. бинарный оператор + лучше всего реализовать как обычную/дружественную функцию;
2. унарный оператор - лучше всего реализовать как функцию-член;
3. оператор << должен быть реализован как обычная/дружественная функция;
4. оператор = должен быть реализован как функция-член.

#include <iostream>
#include <cstdint> // для целочисленных типов фиксированной ширины
 
class Average
{
private:
    // сумма всех чисел, которые мы видели на данный момент
    std::int_least32_t m_total{ 0 }; 
    // количество чисел, которые мы видели на данный момент
    std::int_least8_t m_numbers{ 0 };
 
public:
    Average()
    {
    }
 
    friend std::ostream& operator<<(std::ostream &out, const Average &average)
    {
        // Наше среднее значение - это сумма полученных нами чисел,
        // разделенная на их количество
        // Здесь нужно деление с плавающей запятой, а не целочисленное
        out << static_cast<double>(average.m_total) / average.m_numbers;
 
        return out;
    }
 
    // Поскольку operator+= изменяет свой левый операнд, мы запишем его как член
    Average& operator+=(int num)
    {
        // Увеличиваем нашу сумму на новое число
        m_total += num;
        // И увеличиваем счетчик на 1
        ++m_numbers;
 
        // возвращаем *this на случай,
        // если кто-то захочет объединить += в цепочку
        return *this;
    }
};
 
int main()
{
    Average avg{};
    
    avg += 4;
    std::cout << avg << '\n';
    
    avg += 8;
    std::cout << avg << '\n';
 
    avg += 24;
    std::cout << avg << '\n';
 
    avg += -10;
    std::cout << avg << '\n';
 
    (avg += 6) += 10; // два вызова объединены в цепочку
    std::cout << avg << '\n';
 
    Average copy{ avg };
    std::cout << copy << '\n';
 
    return 0;
}

Нет. Поскольку здесь можно использовать поэлементные инициализацию/копирование, допустимо использование реализаций, предоставленных компилятором по умолчанию.

#include <iostream>
#include <cassert> // для assert
 
class IntArray
{
private:
    int m_length{ 0 };
    int *m_array{ nullptr };
 
public:
    IntArray(int length):
        m_length{ length }
    {
        assert(length > 0 && "IntArray length should be a positive integer");
 
        m_array = new int[m_length]{};
    }
 
    // Конструктор копирования, использующий глубокое копирование
    IntArray(const IntArray &array):
        m_length{ array.m_length }
    {
        // размещаем новый массив
        m_array = new int[m_length];
 
        // копируем элементы из исходного массива в новый
        for (int count{ 0 }; count < array.m_length; ++count)
            m_array[count] = array.m_array[count];
    }
 
    ~IntArray()
    {
        delete[] m_array;
    }
    
    // Если вы получаете здесь непонятные значения, вы, вероятно, забыли
    // выполнить глубокое копирование в своем конструкторе копирования
    friend std::ostream& operator<<(std::ostream &out, const IntArray &array)
    {
        for (int count{ 0 }; count < array.m_length; ++count)
        {
            out << array.m_array[count] << ' ';
        }
        return out;
    }
 
    int& operator[] (const int index)
    {
        assert(index >= 0);
        assert(index < m_length);
        return m_array[index];
    }
    
    // Оператор присваивания, использующий глубокое копирование
    IntArray& operator= (const IntArray &array)
    {
        // защита от самоприсваивания
        if (this == &array)
            return *this;
 
        // если этот массив уже существует, удалить его,
        // чтобы не было утечек памяти
        delete[] m_array;
 
        m_length = array.m_length;
 
        // размещаем новый массив
        m_array = new int[m_length];
 
        // копируем элементы из исходного массива в новый
        for (int count{ 0 }; count < array.m_length; ++count)
            m_array[count] = array.m_array[count];
 
        return *this;
    }
 
};
 
IntArray fillArray()
{
    IntArray a(5);
    a[0] = 5;
    a[1] = 8;
    a[2] = 2;
    a[3] = 3;
    a[4] = 6;
 
    return a;
}
 
int main()
{
    IntArray a{ fillArray() };
 
    // Если вы получаете здесь непонятные значения, вы, вероятно, забыли
    // выполнить глубокое копирование в своем конструкторе копирования
    std::cout << a << '\n';
 
    auto &ref{ a }; // используем эту ссылку, чтобы избежать
                    // ошибок компиляции, связанных с самоприсваиванием
    a = ref;
 
    IntArray b(1);
    b = a;
 
    // Если вы получаете здесь непонятные значения, вы, вероятно, забыли
    // выполнить глубокое копирование в своем операторе присваивания
    std::cout << b << '\n';
 
    return 0;
}

Есть много разных способов реализовать число с фиксированной запятой. Поскольку число с фиксированной запятой, по сути, представляет собой частный случай числа с плавающей запятой (где количество цифр после запятой является фиксированным, а не переменным), очевидным выбором может показаться использование числа с плавающей запятой. Но у чисел с плавающей запятой есть проблемы с точностью. Имея фиксированное количество цифр после запятой, мы можем перечислить все возможные значения дробной части (в нашем случае от 0.00 до 0.99), поэтому использование типа данных, имеющего проблемы с точностью, – не лучший выбор.

Лучшим решением было бы использовать 16-битное целое число со знаком для хранения целой части числа и 8-битное целое число со знаком для хранения дробной части.

#include <iostream>
#include <cstdint> // для целочисленных типов фиксированной ширины
 
class FixedPoint2
{
private:
    std::int_least16_t m_base{};   // здесь наша целая часть
    std::int_least8_t m_decimal{}; // здесь наша дробная часть
 
public:
    FixedPoint2(std::int_least16_t base = 0, std::int_least8_t decimal = 0)
        : m_base{ base }, m_decimal{ decimal }
    {
        // Здесь мы должны обработать случай, когда дробная часть >99 или <-99,
        // но оставим это читателю в качестве упражнения
 
        // Если целая или дробная части отрицательные
        if (m_base < 0 || m_decimal < 0)
        {
            // Убеждаемся, что целая часть отрицательная
            if (m_base > 0)
                m_base = -m_base;
            // Убеждаемся, что дробная часть отрицательная
            if (m_decimal > 0)
                m_decimal = -m_decimal;
        }
    }
 
    operator double() const
    {
        return m_base + static_cast<double>(m_decimal) / 100.0;
    }
};
 
// Эта функция не требует доступа к внутренним компонентам класса,
// поэтому ее можно определить вне класса
std::ostream& operator<<(std::ostream &out, const FixedPoint2 &fp)
{
    out << static_cast<double>(fp);
    return out;
}
 
int main()
{
    FixedPoint2 a{ 34, 56 };
    std::cout << a << '\n';
 
    FixedPoint2 b{ -2, 8 };
    std::cout << b << '\n';
 
    FixedPoint2 c{ 2, -8 };
    std::cout << c << '\n';
 
    FixedPoint2 d{ -2, -8 };
    std::cout << d << '\n';
 
    FixedPoint2 e{ 0, -5 };
    std::cout << e << '\n';
 
    std::cout << static_cast<double>(e) << '\n';
 
    return 0;
}

Вы можете переместить цифру справа от десятичной запятой влево от запятой, умножив ее на 10. Умножьте на 100, чтобы переместить две позиции.

Вы можете получить целую часть числа double с помощью статического преобразования double к int. Чтобы получить дробную часть, вы можете вычесть целую часть.

Вы можете округлить число (слева от десятичной запятой) с помощью функции std::round() (включена в заголовок cmath).

​#include <iostream>
#include <cstdint> // для целочисленных типов фиксированной ширины
#include <cmath>   // для std::round()
 
class FixedPoint2
{
private:
    std::int_least16_t m_base{};   // здесь наша целая часть
    std::int_least8_t m_decimal{}; // здесь наша дробная часть
 
public:
    FixedPoint2(std::int_least16_t base = 0, std::int_least8_t decimal = 0)
        : m_base{ base }, m_decimal{ decimal }
    {
        // Здесь мы должны обработать случай, когда дробная часть >99 или <-99,
        // но оставим это читателю в качестве упражнения
 
        // Если целая или дробная части отрицательные
        if (m_base < 0 || m_decimal < 0)
        {
            // Убеждаемся, что целая часть отрицательная
            if (m_base > 0)
                m_base = -m_base;
            // Убеждаемся, что дробная часть отрицательная
            if (m_decimal > 0)
                m_decimal = -m_decimal;
        }
    }
 
    FixedPoint2(double d):
        m_base{ static_cast<std::int_least16_t>(std::round(d * 100) / 100) },
        m_decimal{ static_cast<std::int_least8_t>(std::round(d * 100) - m_base * 100) }
    {
    }
 
 
    operator double() const
    {
        return m_base + static_cast<double>(m_decimal) / 100.0;
    }
};
 
// Эта функция не требует доступа к внутренним компонентам класса,
// поэтому ее можно определить вне класса
std::ostream& operator<<(std::ostream &out, const FixedPoint2 &fp)
{
    out << static_cast<double>(fp);
    return out;
}
 
int main()
{
    FixedPoint2 a{ 0.01 };
    std::cout << a << '\n';
 
    FixedPoint2 b{ -0.01 };
    std::cout << b << '\n';
 
    FixedPoint2 c{ 5.01 }; // хранится как 5.0099999 ... поэтому нам нужно округлить его
    std::cout << c << '\n';
 
    FixedPoint2 d{ -5.01 }; // хранится как -5.0099999 ... поэтому нам нужно округлить его
    std::cout << d << '\n';
 
    return 0;
}

#include <iostream>
#include <cstdint> // для целочисленных типов фиксированной ширины
#include <cmath>   // для std::round()
 
class FixedPoint2
{
private:
    std::int_least16_t m_base{};   // здесь наша целая часть
    std::int_least8_t m_decimal{}; // здесь наша дробная часть
 
public:
    FixedPoint2(std::int_least16_t base = 0, std::int_least8_t decimal = 0)
        : m_base{ base }, m_decimal{ decimal }
    {
        // Здесь мы должны обработать случай, когда дробная часть >99 или <-99,
        // но оставим это читателю в качестве упражнения
 
        // Если целая или дробная части отрицательные
        if (m_base < 0 || m_decimal < 0)
        {
            // Убеждаемся, что целая часть отрицательная
            if (m_base > 0)
                m_base = -m_base;
            // Убеждаемся, что дробная часть отрицательная
            if (m_decimal > 0)
                m_decimal = -m_decimal;
        }
    }
 
    FixedPoint2(double d):
        m_base{ static_cast<std::int_least16_t>(std::round(d * 100) / 100) },
        m_decimal{ static_cast<std::int_least8_t>(std::round(d * 100) - m_base * 100) }
    {
    }
 
    operator double() const
    {
        return m_base + static_cast<double>(m_decimal) / 100;
    }
 
    friend bool operator==(const FixedPoint2 &fp1, const FixedPoint2 &fp2)
    {
        return (fp1.m_base == fp2.m_base && fp1.m_decimal == fp2.m_decimal);
    }
 
    FixedPoint2 operator-() const
    {
        // Нам нужно приведение, потому что отрицательный знак (-)
        // преобразует наши узкие целочисленные типы в int.
        return {
            static_cast<std::int_least16_t>(-m_base),
            static_cast<std::int_least8_t>(-m_decimal)
        };
    }
};
 
// Эта функция не требует доступа к внутренним компонентам класса,
// поэтому ее можно определить вне класса
std::ostream& operator<<(std::ostream &out, const FixedPoint2 &fp)
{
    out << static_cast<double>(fp);
    return out;
}
 
std::istream& operator >> (std::istream &in, FixedPoint2 &fp)
{
    double d{};
    in >> d;
    fp = FixedPoint2{ d };
 
    return in;
}
 
FixedPoint2 operator+(const FixedPoint2 &fp1, const FixedPoint2 &fp2)
{
    return { static_cast<double>(fp1) + static_cast<double>(fp2) };
}
 
void testAddition()
{
    std::cout << std::boolalpha;
    // оба положительные, без переполнения дробной части
    std::cout << (FixedPoint2{ 0.75 } + FixedPoint2{ 1.23 } == FixedPoint2{ 1.98 }) << '\n';
    // оба положительные, с переполнением дробной части
    std::cout << (FixedPoint2{ 0.75 } + FixedPoint2{ 1.50 } == FixedPoint2{ 2.25 }) << '\n';
    // оба отрицательные, без переполнения дробной части
    std::cout << (FixedPoint2{ -0.75 } + FixedPoint2{ -1.23 } == FixedPoint2{ -1.98 }) << '\n';
    // оба отрицательные, с переполнением дробной части
    std::cout << (FixedPoint2{ -0.75 } + FixedPoint2{ -1.50 } == FixedPoint2{ -2.25 }) << '\n';
    // второе отрицательное, без переполнения дробной части
    std::cout << (FixedPoint2{ 0.75 } + FixedPoint2{ -1.23 } == FixedPoint2{ -0.48 }) << '\n';
    // второе отрицательное, возможно переполнение дробной части
    std::cout << (FixedPoint2{ 0.75 } + FixedPoint2{ -1.50 } == FixedPoint2{ -0.75 }) << '\n';
   // первое отрицательное, без переполнения дробной части
    std::cout << (FixedPoint2{ -0.75 } + FixedPoint2{ 1.23 } == FixedPoint2{ 0.48 }) << '\n';
    // первое отрицательное, возможно переполнение дробной части
    std::cout << (FixedPoint2{ -0.75 } + FixedPoint2{ 1.50 } == FixedPoint2{ 0.75 }) << '\n';
}
 
int main()
{
    testAddition();
 
    FixedPoint2 a{ -0.48 };
    std::cout << a << '\n';
 
    std::cout << -a << '\n';
 
    std::cout << "Enter a number: "; // введите 5.678
    std::cin >> a;
    
    std::cout << "You entered: " << a << '\n';
 
    return 0;
}