Создание класса, представляющего многочлен

06.08.2010, 11:10. **Показов** 1887. **Ответов** 5

Студворк — интернет-сервис помощи студентам

Доброго времени суток, Профессионалы!
Имеется задание:
Создать класс Polynom ( многочлен ) с операциями +, +=, -, -=, =, ==, !=, >, <, >=, <=, *, *=
Для выполнения операций >, <, >=, <=, надо подставить некоторое число вместо X?
И , что делать с ==, != ?

Евгений М. · 06.08.2010, 11:17

Скорее всего надо сравнивать степени многочлена.

Сообщение от Domen0

надо подставить некоторое число вместо X?

Это как?

@Nameless One · 06.08.2010, 11:53

Сообщение от Domen0

И , что делать с ==, != ?

Ну очевидно же, что два многочлена равны, если их коэффициенты при соответствующих степенях x равны между собой.
А вот что делать с остальными операторами сравнения, и вправду непонятно...

@Johnny_D · 06.08.2010, 11:59

Проверять коэффициенты старших степеней, потом более младших, если число >1 и положительно, >1 и отрицательно, <1 и положитель, и <1 и отрицательно. Приблизительный ответ можно дать сразу.

@Nameless One · 06.08.2010, 14:21

Johny_D, чего-то я не понял. Объясни, пожалуйста, на примере, как сравнить два следующих многочлена: $https://www.cyberforum.ru/cgi-bin/latex.cgi?2.5 + 3{x} - 5{x}^{2} + 18{x}^{3}$ и $https://www.cyberforum.ru/cgi-bin/latex.cgi?-2 + 9.6{x} - 200{x}^{2} + 10{x}^{3}$ ?

Добавлено через 38 минут
Кстати, можно будет определить методы, возвращающие производную и первообразную...

Добавлено через 1 час 26 минут

Вот моя реализация:

Как должны работать операторы >=, <=, >, <, я так и не додумался.
Тестил, вроде все работает правильно:

polynom.h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#ifndef POLYNOM_H
#define POLYNOM_H
 
#include <iostream>
#include <iomanip>
 
namespace my
{
    class polynom
    {
    public:
        polynom(char letter = DEFAULT_LETTER);
        polynom(size_t size, const double* coeffs, char letter = DEFAULT_LETTER);
        polynom(const polynom& rhs);
        ~polynom();
 
        double operator () (double X) const; // Возвращает значение полинома для x=X
        polynom& operator = (const polynom& rhs);
        polynom operator - () const;
        bool operator == (const polynom& rhs) const;
        bool operator != (const polynom& rhs) const;
        polynom operator + (const polynom& rhs) const;
        polynom& operator += (const polynom& rhs);
        polynom operator - (const polynom& rhs) const;
        polynom& operator -= (const polynom& rhs);
        polynom operator * (const polynom& rhs) const;
        polynom& operator *= (const polynom& rhs);
 
        polynom derivative() const; // Возвращает производную
        polynom antiderivative() const; // Возвращает первообразную
 
        friend std::ostream& operator << (std::ostream& os, const polynom& rhs);
 
    private:
        // Массив, в котором хранятся коэффициенты полинома:
        // i-тый коэффициент при i-той степени
        double*     m_pCoeffs;
        size_t      m_nSize; // Размер полинома
        char        m_cLetter; //Символ для вывода (только латинские буквы любого регистра)
 
        static const char DEFAULT_LETTER = 'x';
    };
};
 
#endif

polinom.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
#include "polynom.h"
 
#include <algorithm>
#include <map>
#include <stdexcept>
 
namespace my
{
    polynom::polynom(char letter)
        : m_nSize(0), m_pCoeffs(NULL)
    {
        char lower = tolower(letter);
        if((letter < 'a') || (letter > 'z'))
            throw(std::invalid_argument("Invalid letter"));
        m_cLetter = letter;
    }
 
 
    polynom::polynom(size_t size, const double* coeffs, char letter)
        : m_nSize(size)
    {
        char lower = tolower(letter);
        if((letter < 'a') || (letter > 'z'))
            throw(std::invalid_argument("Invalid letter"));
        m_cLetter = letter;
        m_pCoeffs = new double [m_nSize];
        std::copy(coeffs, coeffs + m_nSize, m_pCoeffs);
    }
 
 
    polynom::polynom(const polynom& rhs)
        : m_nSize(rhs.m_nSize), m_cLetter(rhs.m_cLetter)
    {
        m_pCoeffs = new double [m_nSize];
        std::copy(rhs.m_pCoeffs, rhs.m_pCoeffs + m_nSize, m_pCoeffs);
    }
 
    polynom::~polynom()
    {
        delete[] m_pCoeffs;
        m_nSize = 0;
    }
 
 
    double polynom::operator () (double X) const
    {
        double returnValue = 0;
        double pow = 1;
        for(size_t i = 0; i < m_nSize; ++i, pow *= X)
            returnValue += m_pCoeffs[i] * pow;
        return returnValue;
    }
 
 
    polynom& polynom::operator = (const polynom& rhs)
    {
        m_nSize = rhs.m_nSize;
        m_pCoeffs = new double [m_nSize];
        m_cLetter = rhs.m_cLetter;
        std::copy(rhs.m_pCoeffs, rhs.m_pCoeffs + m_nSize, m_pCoeffs);
        return *this;
    }
 
 
    polynom polynom::operator - () const
    {
        polynom temp(*this);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pCoeffs[i] *= -1;
        return temp;
    }
 
 
    bool polynom::operator == (const polynom& rhs) const
    {
        if(rhs.m_nSize != m_nSize)
            return false;
        for(size_t i = 0; i < m_nSize; ++i)
            if(m_pCoeffs[i] != rhs.m_pCoeffs[i])
                return false;
        return true;
    }
 
 
    bool polynom::operator != (const polynom& rhs) const
    {
        return !(*this == rhs);
    }
 
 
    polynom polynom::operator + (const polynom& rhs) const
    {
        double* ptrMax, * ptrMin;
        size_t max, min;
        if(rhs.m_nSize >= m_nSize)
        {
            max = rhs.m_nSize;
            min = m_nSize;
            ptrMax = rhs.m_pCoeffs;
            ptrMin = m_pCoeffs;
        }
        else
        {
            max = m_nSize;
            min = rhs.m_nSize;
            ptrMax = m_pCoeffs;
            ptrMin = rhs.m_pCoeffs;
        }
        double* temp = new double[max] ();
        std::copy(ptrMax, ptrMax + max, temp);
        for(size_t i = 0; i < min; ++i)
            temp[i] += ptrMin[i];
        polynom ret(max, temp, m_cLetter);
        delete[] temp;
        return ret;
    }
 
 
    polynom& polynom::operator += (const polynom& rhs)
    {
        return (*this = *this + rhs);
    }
 
 
    polynom polynom::operator - (const polynom& rhs) const
    {
        return (*this + (-rhs));
    }
 
 
    polynom& polynom::operator -= (const polynom& rhs)
    {
        return (*this = *this - rhs);
    }
 
 
    polynom polynom::operator * (const polynom& rhs) const
    {
        std::map<int, double> coeffs;
        for(size_t i = 0; i < m_nSize; ++i)
            for(size_t j = 0; j < rhs.m_nSize; ++j)
                coeffs[i + j] += m_pCoeffs[i] * rhs.m_pCoeffs[j];
        size_t size = coeffs.size();
        double* temp = new double[size] ();
        for(std::map<int, double>::const_iterator it = coeffs.begin();
            it != coeffs.end();
            ++it)
            temp[it->first] = it->second;
        polynom ret(size, temp, m_cLetter);
        delete[] temp;
        return ret;
    }
 
 
    polynom& polynom::operator *= (const polynom& rhs)
    {
        return (*this = *this * rhs);
    }
 
 
    polynom polynom::derivative() const
    {
        size_t size = m_nSize - 1;
        double* temp = new double[size] ();
        for(size_t i = 0; i < size; ++i)
            temp[i] = m_pCoeffs[i + 1] * (i + 1);
        polynom ret(size, temp, m_cLetter);
        delete[] temp;
        return ret;
    }
 
 
    polynom polynom::antiderivative() const
    {
        size_t size = m_nSize + 1;
        double* temp = new double[size] ();
        for(size_t i = 0; i < m_nSize; ++i)
            if(m_pCoeffs[i])
                temp[i + 1] = m_pCoeffs[i] / (static_cast<double>(i + 1));
        polynom ret(size, temp, m_cLetter);
        delete[] temp;
        return ret;
    }
 
    std::ostream& operator << (std::ostream& os, const polynom& rhs)
    {
        for(size_t i = 0; i < rhs.m_nSize; ++i)
            if(rhs.m_pCoeffs[i])
                std::cout << std::setprecision(4)
                << (rhs.m_pCoeffs[i] > 0 ? "+" : "-") << std::abs(rhs.m_pCoeffs[i])
                << rhs.m_cLetter << '^' << i;
        return os;
    }
};

main.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <iostream>
#include <algorithm>
#include <ctime>
 
#include "polynom.h"
 
#define dbg(EXP) std::cout << std::boolalpha << #EXP ": " << (EXP) << std::endl
 
int main()
{
    try
    {
        srand(static_cast<size_t>(time(NULL)));
        const size_t M = 2;
        const size_t K = 3;
        const int uB = 100;
        const int lB = -100;
        double arrayM[M];
        double arrayK[K];
        std::generate(arrayM, arrayM + M, [lB, uB]() { return (lB + rand() % (lB - uB + 1)) / 10.0; });
        std::generate(arrayK, arrayK + K, [lB, uB]() { return (lB + rand() % (lB - uB + 1)) / 10.0; });
        my::polynom mPol(M, arrayM, 'm');
        my::polynom kPol(K, arrayK, 'k');
        dbg(mPol);
        dbg(kPol);
        dbg(-kPol);
        dbg(kPol.derivative());
        dbg(kPol.antiderivative());
        dbg(kPol + mPol);
        dbg(kPol - mPol);
        dbg(kPol * mPol);
        dbg(kPol == mPol);
        my::polynom kCopy(kPol);
        dbg(kCopy == kPol);
        dbg(mPol(5));
    }
    catch(std::exception& e)
    {
        std::cout << e.what() << std::endl;
    }
    system("pause");
    return EXIT_SUCCESS;
}

Добавлено через 10 минут
PS. Можно еще перегрузить оператор [], чтобы возвращать коэффициент при i-том члене многочлена. Ну и функцию size() написать.

@Shaper · 06.08.2010, 17:09

Сообщение от Domen0

Доброго времени суток, Профессионалы!
Имеется задание:
Создать класс Polynom ( многочлен ) с операциями +, +=, -, -=, =, ==, !=, >, <, >=, <=, *, *=
Для выполнения операций >, <, >=, <=, надо подставить некоторое число вместо X?
И , что делать с ==, != ?

Класс должен представлять из себя несколько функций, выполняющих действия, и массива офигительной длины, который хранит коэффициенты при x. Так как степень многочлена не задана, она может быть какой угодно.

+ и - - это просто складываются или вычитаются соответствующие коэффициенты. Если у нас есть (ax2+bx+c) и (dx2+ex+f), то их сумма будет равна (a+d)x2+(b+e)x+(c+f);

< и > - это тоже просто. Нужно определить с какой скоростью многочлены уходят в бесконечность. Кто с большей скоростью уходит, тот и больше. Для этого сначала сравниваются коэффициенты при наибольшей степени, а если они равны, то уходим на низшую степень и сравниваем там и так далее, до тех пор, пока не встретятся разные коэффициенты.

== - это тоже просто. Если все коэффициенты равны, то полиномы равны. Иначе не равны.

* - это посложнее. Это каждый член нужно умножать на каждый. При этом степень полинома увеличивается. Новая степень будет суммой степеней умножаемых полиномов.

(ax2+bx+c) * (dx2+ex+f) =
= adx4+aex3+afx2 + bdx3+bex2+bfx + cdx2+cex+cf =
= adx4+(ae+bd)x3+(af+be+cd)x2+(bf+ce)x+cf

Проблема тут только в том, чтобы сделать умножение полиномов для общего случая, и чтобы программа могла переваривать полиномы 100-й степени без проблем. При умножении 2-х полиномов 100-й степени будет полином 200-й степени. Так что, тут еще и с выделяемой памятью нужно вопрос решить.

Новые блоги и статьи Все статьи Все блоги /
Оттенки серого Argus19 18.03.2026 Оттенки серого Нашёл в интернете 3 прекрасных модуля: Модуль класса открытия диалога открытия/ сохранения файла на Win32 API; Модуль класса быстрого перекодирования цветного изображения в оттенки. . .	SDL3 для Desktop (MinGW): Рисуем цветные прямоугольники с помощью рисовальщика SDL3 на Си и C++ 8Observer8 17.03.2026 Содержание блога Финальные проекты на Си и на C++: finish-rectangles-sdl3-c. zip finish-rectangles-sdl3-cpp. zip	Символические и жёсткие ссылки в Linux. algri14 15.03.2026 Существует два типа ссылок — символические и жёсткие. Ссылка в Linux — это запись в каталоге, которая может указывать либо на inode «файла-ИСТОЧНИКА», тогда это будет «жёсткая ссылка» (hard link),. . .	[Owen Logic] Поддержание уровня воды в резервуаре количеством включённых насосов: моделирование и выбор регулятора ФедосеевПавел 14.03.2026 Поддержание уровня воды в резервуаре количеством включённых насосов: моделирование и выбор регулятора ВВЕДЕНИЕ Выполняя задание на управление насосной группой заполнения резервуара,. . .
делаю науч статью по влиянию грибов на сукцессию anaschu 13.03.2026 прикрепляю статью	SDL3 для Desktop (MinGW): Создаём пустое окно с нуля для 2D-графики на SDL3, Си и C++ 8Observer8 10.03.2026 Содержание блога Финальные проекты на Си и на C++: hello-sdl3-c. zip hello-sdl3-cpp. zip Результат:	Установка CMake и MinGW 13.1 для сборки С и C++ приложений из консоли и из Qt Creator в EXE 8Observer8 10.03.2026 Содержание блога MinGW - это коллекция инструментов для сборки приложений в EXE. CMake - это система сборки приложений. Здесь описаны базовые шаги для старта программирования с помощью CMake и. . .	Как дизайн сайта влияет на конверсию: 7 решений, которые реально повышают заявки Neotwalker 08.03.2026 Многие до сих пор воспринимают дизайн сайта как “красивую оболочку”. На практике всё иначе: дизайн напрямую влияет на то, оставит человек заявку или уйдёт через несколько секунд. Даже если у вас. . .

Domen0

	Создание класса, представляющего многочлен 06.08.2010, 11:10. Показов 1887. Ответов 5 Метки нет (Все метки) Доброго времени суток, Профессионалы! Имеется задание: Создать класс Polynom ( многочлен ) с операциями +, +=, -, -=, =, ==, !=, >, <, >=, <=, , = Для выполнения операций >, <, >=, <=, надо подставить некоторое число вместо X? И , что делать с ==, != ?

@Johnny_D Padawan 473 / 323 / 30 Регистрация: 30.01.2010 Сообщений: 1,841
	06.08.2010, 11:59
	Проверять коэффициенты старших степеней, потом более младших, если число >1 и положительно, >1 и отрицательно, <1 и положитель, и <1 и отрицательно. Приблизительный ответ можно дать сразу. 0

Создание класса, представляющего многочлен

Решение