Форум программистов, компьютерный форум CyberForum.ru
Наши страницы

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

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Нахождение кратчайшего пути по матрице, или передвижение привидений в игре Пакмен http://www.cyberforum.ru/cpp-beginners/thread687176.html
Подскажите пожалуйста как правильно реализовать? Имеются координаты x,y пакмана и приведения. Я использую такой алгоритм: void Enemy::move(Map* map, Puckman* Puckman, Enemy* en) { if(Puckman...
C++ Создать матрицу 7х7, найти максимальный и минимальный элементы, и поменять строки где они находятся Нужно создать масив 7 на 7 найти максимальный и минимальный елемент и поменять строки где находятся эти елементы Вот собственно написал, но тут либо ошибка либо неправильно написал #include... http://www.cyberforum.ru/cpp-beginners/thread687161.html
C++ Нужно подсчитать количество букв Т в заданой строке
у меня есть код #include<iostream.h> #include<string.h> #include<conio.h> void main() { clrscr(); char str; int i; cin>>str; for
Вычислить максимальный по модулю элемент массива C++
Помогите, пожалуйста
C++ Создать новый связный список из различных элементов данного http://www.cyberforum.ru/cpp-beginners/thread687123.html
Создать связный список. Создать новый список из различных элементов данного, включив в информационную часть узла количество его вхождения в первоначальный список. Помогите сделать каким то другим ...
C++ Обработка исключений Объясните мне толком для чего используются эти обработки исключений (Try, catch, throw). Сколько не читаю, не могу понять для чего и как это все используется... Можете привести какой нибудь простой... подробнее

Показать сообщение отдельно
Buckstabue
175 / 124 / 6
Регистрация: 12.01.2012
Сообщений: 624

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

02.11.2012, 21:17. Просмотров 635. Ответов 5
Метки (Все метки)

Пишу шаблонный класс матриц. Делаю, значит, переопределение оператора + для двух матриц одного типа. Но компилятор ругается на эту функцию
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. Но думаю в тестовом примере он не нужен, так что если не компилится, можете те места где он встречается закомментировать/удалить
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru