При возврате объекта из функции пишет, что для объекта не определен констуктор копирования

@Buckstabue · Регистрация: 12.01.2012

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

Пишу шаблонный класс матриц. Делаю, значит, переопределение оператора + для двух матриц одного типа. Но компилятор ругается на эту функцию
matrix.hpp:141:11: error: no matching function for call to 'Matrix<int>::Matrix(Matrix<int>&)'
Что это значит? Как это исправить?
Сама тестовая программа
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
#include <iostream>
#include "matrix.hpp"
 
using namespace std;
 
template < class T >
std::ostream& operator<<(std::ostream& out, const Matrix<T>& matrix);
 
int main()
{
   Matrix<int> matrix(10, 10);
   Matrix<int> matrix2(matrix);
 
   matrix.at(1, 1) = 1;
 
   std::cout << (matrix  + matrix2);
 
   return 0;
}
 
// ------------------------------------------------------------
template < class T >
std::ostream& operator<<(std::ostream& out, const Matrix<T>& matrix)
{
   const int m = matrix.getNumColumns();
   const int n = matrix.getNumRows();
 
   for (int i = 0; i < m; ++i)
   {
      for (int j = 0; j < n; ++j)
      {
         out << matrix.at(i, j) << ' ';
      }
 
      out << std::endl;
   }
 
   return out;
}

matrix.hpp

Кликните здесь для просмотра всего текста

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
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
#ifndef MATRIX_HPP
#define MATRIX_HPP
 
#include "bad_matrix.hpp"
#include "incompatible_matrix.hpp"
 
#include <vector>
 
template<class T>
class Matrix
{
public:
   explicit
   Matrix(const int _m, const int _n);
   explicit
   Matrix(const Matrix<T>& other);
   Matrix<T>& operator=(const Matrix<T>& other);
   virtual
   ~Matrix();
   Matrix operator+(const Matrix<T>& other);
   Matrix operator-(const Matrix<T>& other);
   Matrix operator*(const Matrix<T>& other);
   // умножение вектора на скалярное число
   Matrix operator*(const long x);
   Matrix operator*(const double& x);
   void operator+=(const Matrix<T>& other);
   void operator-=(const Matrix<T>& other);
   void operator*=(const Matrix<T>& other);
   bool operator==(const Matrix<T>& other);
 
   // Возвращает детерминант для квадратной матрицы
   T determinant();
   inline
   bool isSquare() const;
 
   inline
   long getNumRows() const;
 
   inline
   long getNumColumns() const;
 
   inline
   T& at(long i, long j) { return matrix[i][j]; }
 
   inline
   const T& at(long i, long j) const { return matrix[i][j]; }
 
   Matrix<T> pow(int power);
private:
   long int numRows;
   long int numColumns;
   std::vector< std::vector<T> > matrix;
 
};
// ----------------------------------------------------------
template< class T >
Matrix<T>::Matrix(const int _m, const int _n) :
   numRows(_m), numColumns(_n)
{
   // основной констурктор
   if (numRows <= 0 || numColumns <= 0)
   {
      throw bad_matrix("invalid dimension for matrix");
   }
 
   matrix.resize(numRows);
   for (auto &it : matrix)
   {
      it.resize(numColumns);
   }
 
   for (auto &it : matrix)
   {
      std::fill(it.begin(), it.end(), 0);
   }
}
// ----------------------------------------------------------
/* конструктор копирования */
template< class T >
Matrix<T>::Matrix(const Matrix<T>& other) :
   numRows(other.getNumRows()), numColumns(other.getNumColumns())
{
 
   matrix.resize(numRows); // изменяем размер контейнера до минимально необходимого
   for (auto &it : matrix)
   {
      it.resize(numColumns);
   }
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numRows; ++j)
      {
         matrix[i][j] = other.at(i, j);
      }
   }
}
// ----------------------------------------------------------
template<class T>
Matrix<T>& Matrix<T>::operator=(const Matrix<T>& other)
{
   numRows = other.getNumRows();
   numColumns = other.getNumColumns();
 
   matrix.resize(numRows);
   for (auto &it : matrix)
   {
      it.resize(numColumns);
   }
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numRows; ++j)
      {
         matrix[i][j] = other.at(i, j);
      }
   }
 
   return (*this);
}
// ----------------------------------------------------------
template< class T >
Matrix<T> Matrix<T>::operator+(const Matrix<T>& other)
{
   if (numRows != other.getNumRows() || numColumns != other.getNumColumns())
   {
      // если матрицы имеют разные размеры для них не определена операция сложения
      throw bad_matrix();
   }
 
   Matrix<T> resultMatrix(*this);
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numColumns; ++j)
      {
         resultMatrix.at(i , j) += other.at(i, j);
      }
   }
 
   return resultMatrix;
}
// ----------------------------------------------------------
template< class T >
void Matrix<T>::operator+=(const Matrix<T>& other)
{
   *this = (*this) + other;
}
// ----------------------------------------------------------
template< class T >
Matrix<T>::~Matrix()
{
}
// ----------------------------------------------------------
template< class T >
long Matrix<T>::getNumRows() const
{
   return numRows;
}
// ----------------------------------------------------------
template< class T >
long Matrix<T>::getNumColumns() const
{
   return numColumns;
}
// ----------------------------------------------------------
template < class T >
bool Matrix<T>::isSquare() const
{
   return (numColumns == numRows);
}
// ----------------------------------------------------------
template < class T >
bool Matrix<T>::operator==(const Matrix<T>& other)
{
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numColumns; ++j)
      {
         if (matrix[i][j] != other.at(i, j))
            return false;
      }
   }
 
   return true;
}
// ----------------------------------------------------------
template < class T >
Matrix<T> Matrix<T>::pow(int power)
{
   if (!isSquare())
   {
      throw bad_matrix();
   }
   if (power < 0); // FIXME сделать что-либо
 
 
   if (power == 0)
   {
      Matrix<T> resultMatrix(numRows, numColumns);
 
      for (int i = 0; i < numRows; ++i)
      {
         resultMatrix.at(i, i) = 1;
      }
 
      return resultMatrix;
   }
   else
   {
      Matrix<T> resultMatrix(*this);
 
      for (int i = 1; i < power; ++i)
      {
         resultMatrix *= (*this);
      }
 
      return resultMatrix;
   }
}
// ----------------------------------------------------------
template< class T >
Matrix<T> Matrix<T>::operator-(const Matrix<T>& other)
{
   if (numRows != other.getNumRows() || numColumns != other.getNumColumns())
   {
      // если матрицы имеют разные размеры для них не определена операция вычитания
      throw bad_matrix();
   }
 
   Matrix<T> resultMatrix(*this);
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numColumns; ++j)
      {
         resultMatrix.at(i , j) -= other.at(i, j);
      }
   }
 
   return resultMatrix;
}
 
// ----------------------------------------------------------
template < class T >
void Matrix<T>::operator*=(const Matrix<T>& other)
{
   *this = (*this) * other;
}
// ----------------------------------------------------------
template< class T >
void Matrix<T>::operator-=(const Matrix<T>& other)
{
   *this = (*this) - other;
}
// ----------------------------------------------------------
template< class T >
Matrix<T> Matrix<T>::operator*(const long x)
{
   Matrix<T> resultMatrix(*this);
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numColumns; ++j)
      {
         resultMatrix(i, j) *= x;
      }
   }
 
   return resultMatrix;
}
// ----------------------------------------------------------
template< class T >
Matrix<T> Matrix<T>::operator*(const double& x)
{
   Matrix<T> resultMatrix(*this);
 
   for (int i = 0; i < numRows; ++i)
   {
      for (int j = 0; j < numColumns; ++j)
      {
         resultMatrix(i, j) *= x;
      }
   }
 
   return resultMatrix;
}
 
// ----------------------------------------------------------
#endif // MATRIX_HPP

incompatible_matrix.hpp

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef INCOMPATIBLE_MATRIX_HPP
#define INCOMPATIBLE_MATRIX_HPP
 
#include "bad_matrix.hpp"
 
#include <stdexcept>
 
class incompatible_matrix : public bad_matrix
{
public:
   incompatible_matrix();
   virtual ~incompatible_matrix() noexcept;
   virtual const char * what() const noexcept;
private:
   static const char * errMsg;
};
 
#endif // INCOMPATIBLE_MATRIX_HPP

incompatible_matrix.cpp

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include "incompatible_matrix.hpp"
 
const char * incompatible_matrix::errMsg = "incompatible matrix";
 
incompatible_matrix::incompatible_matrix()
{
}
 
incompatible_matrix::~incompatible_matrix() noexcept
{
}
 
const char *incompatible_matrix::what() const noexcept
{
   return errMsg;
}

P.S. писалось все в лоб и на скорую руку, так что с удовольствием также приму любую критику.
P.P.S. кажется, код содержит C++11

Добавлено через 8 минут
Хм. Уже заметил, что в строках 282 и 266 вместо resultMatrix(i, j) надо писать resultMatrix.at(i, j)

Добавлено через 20 минут
Еще забыл выложить класс bad_matrix. Но думаю в тестовом примере он не нужен, так что если не компилится, можете те места где он встречается закомментировать/удалить

@rangerx · 02.11.2012, 21:29

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

void operator+=(const Matrix<T>& other);
void operator-=(const Matrix<T>& other);
void operator*=(const Matrix<T>& other);

Эти методы обычно возвращают ссылку, как и оператор присваивания.

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

Matrix operator+(const Matrix<T>& other);
Matrix operator-(const Matrix<T>& other);
Matrix operator*(const Matrix<T>& other);
Matrix operator*(const long x);
Matrix operator*(const double& x);
bool operator==(const Matrix<T>& other);

Все эти методы должны быть константны, в противном случае они не будут работать для константных объектов.

@Buckstabue · 02.11.2012, 21:35 **[ТС]**

Спасибо. Еще забыл прописать в заголовке функций параметр Matrix<T> т.е. возвращает не просто матрицу

@soon · 02.11.2012, 21:38

Buckstabue, explicit уберите

@Buckstabue · 02.11.2012, 21:43 **[ТС]**

soon, ОГРОМНОЕ спасибо!!! Крепко вас целую =)

@soon · 02.11.2012, 22:03

Buckstabue, кстати, раз уж используете C++11, не мешало бы реализовать move-constructor и move-assignment-operator

Новые блоги и статьи Все статьи Все блоги /
YAFU@home — распределённые вычисления для математики. На CPU Programma_Boinc 20.01.2026 YAFU@home — распределённые вычисления для математики. На CPU YAFU@home — это BOINC-проект, который занимается факторизацией больших чисел и исследованием aliquot-последовательностей. Звучит. . .	http://iceja.net/ математические сервисы iceja 20.01.2026 Обновила свой сайт http:/ / iceja. net/ , приделала Fast Fourier Transform экстраполяцию сигналов. Однако предсказывает далеко не каждый сигнал (см ограничения http:/ / iceja. net/ fourier/ docs ). Также. . .	http://iceja.net/ сервер решения полиномов iceja 18.01.2026 Выкатила http:/ / iceja. net/ сервер решения полиномов (находит действительные корни полиномов методом Штурма). На сайте документация по API, но скажу прямо VPS слабенький и 200 000 полиномов. . .	Расчёт переходных процессов в цепи постоянного тока igorrr37 16.01.2026 / * Дана цепь постоянного тока с R, L, C, k(ключ), U, E, J. Программа составляет систему уравнений по 1 и 2 законам Кирхгофа, решает её и находит: токи, напряжения и их 1 и 2 производные при t = 0;. . .
Восстановить юзерскрипты Greasemonkey из бэкапа браузера damix 15.01.2026 Если восстановить из бэкапа профиль Firefox после переустановки винды, то список юзерскриптов в Greasemonkey будет пустым. Но восстановить их можно так. Для этого понадобится консольная утилита. . .	Сукцессия микоризы: основная теория в виде двух уравнений. anaschu 11.01.2026 https:/ / rutube. ru/ video/ 7a537f578d808e67a3c6fd818a44a5c4/	WordPad для Windows 11 Jel 10.01.2026 WordPad для Windows 11 — это приложение, которое восстанавливает классический текстовый редактор WordPad в операционной системе Windows 11. После того как Microsoft исключила WordPad из. . .	Classic Notepad for Windows 11 Jel 10.01.2026 Old Classic Notepad for Windows 11 Приложение для Windows 11, позволяющее пользователям вернуть классическую версию текстового редактора «Блокнот» из Windows 10. Программа предоставляет более. . .

@Buckstabue 179 / 127 / 25 Регистрация: 12.01.2012 Сообщений: 623
	02.11.2012, 21:35 [ТС]
	Спасибо. Еще забыл прописать в заголовке функций параметр Matrix<T> т.е. возвращает не просто матрицу 0

@soon 2554 / 1319 / 178 Регистрация: 09.05.2011 Сообщений: 3,086 Записей в блоге: 1
	02.11.2012, 21:38
	Buckstabue, explicit уберите 1

@Buckstabue 179 / 127 / 25 Регистрация: 12.01.2012 Сообщений: 623
	02.11.2012, 21:43 [ТС]
	soon, ОГРОМНОЕ спасибо!!! Крепко вас целую =) 0

@soon 2554 / 1319 / 178 Регистрация: 09.05.2011 Сообщений: 3,086 Записей в блоге: 1
	02.11.2012, 22:03
	Buckstabue, кстати, раз уж используете C++11, не мешало бы реализовать move-constructor и move-assignment-operator 1