Garniturek Temat założony przez niniejszego użytkownika |
Przeciążony operator + » 2016-03-15 14:36:50 Witam, przeciążyłem sobie operator + i teraz nie mam pojęcia jak zrobić, aby dodać dwa vectory za pomocą jego. (dodawanie macierzy) class cMatrix
{
int kolumny;
int wiersze;
public:
vector < vector < int >> vec;
vector < vector < int >> vec_2;
cMatrix operator +();
cMatrix cMatrix::operator +()
{
cMatrix suma( kolumny, wiersze );
for( int i = 0; i < vec_2.size(); i++ )
{
for( int j = 0; j < vec_2[ i ].size(); j++ )
{
vec[ i ][ j ] += vec_2[ i ][ j ];
suma.vec;
}
}
return suma;
}
cMatrix a;
case '7':
{
system( "cls" );
a.vec + a.vec_2;
} break;
|
|
carlosmay |
» 2016-03-15 15:40:29 cMatrix a;
cMatrix b;
cMatrix wynik;
wynik = a + b;
Jeżeli ma to być dodawanie wektorów jednego obiektu, napisz metodę sumującą te wektory. Pomyśl gdzie zapisać wynik tego dodawania. |
|
Garniturek Temat założony przez niniejszego użytkownika |
» 2016-03-15 16:21:26 Czyli dobrze rozumiem, że tak jak ja chce, czyli mieć jedną zmienna cMatrix i przeciążyć operator dodawania tak, aby dodawał dwa elementy tej zmiennej się nie da? Mam metodę dodawania, ale też potrzebuję zrobić to przeciążanie Dodaje do jednego z vectorów drugi vector, więc wynik sumy jest w tym pierwszym vectorze void cMatrix::dodawanie()
{
for( int i = 0; i < vec_2.size(); i++ )
{
for( int j = 0; j < vec_2[ i ].size(); j++ )
{
vec[ i ][ j ] += vec_2[ i ][ j ];
}
}
}
|
|
carlosmay |
» 2016-03-15 16:45:53 | Czyli dobrze rozumiem, że tak jak ja chce, czyli mieć jedną zmienna cMatrix i przeciążyć operator dodawania tak, aby dodawał dwa elementy tej zmiennej się nie da? |
Tego nie wiem. Choć nie widziałem takich rozwiązań. Taki operator można napisać na zewnątrz. Argumentami i typem zawracanym powinien być ten wektor. Przecież jest do tych wektorów dostęp publiczny. |
|
Garniturek Temat założony przez niniejszego użytkownika |
» 2016-03-15 17:37:43 Program działa(bez errorów itp), tylko nie wyświetla mi wyniku. Pomocy! class cMatrix
{
int kolumny;
int wiersze;
public:
vector < vector < int >> vec;
cMatrix operator +( const cMatrix & Macierz );
cMatrix cMatrix::operator +( const cMatrix & Macierz )
{
cMatrix suma( kolumny, wiersze );
for( int i = 0; i < wiersze; i++ )
{
vector < int > wiersz_vec;
for( int j = 0; j < vec[ i ].size(); j++ )
{
wiersz_vec.push_back( vec[ i ][ j ] + Macierz.vec[ i ][ j ] );
}
suma.vec.push_back( wiersz_vec );
}
return suma;
}
void cMatrix::wyswietl()
{
for( int i = 0; i < vec.size(); i++ )
{
for( int j = 0; j < vec[ i ].size(); j++ )
{
cout << vec[ i ][ j ] << " ";
}
cout << endl;
}
}
cMatrix a;
cMatrix b;
case '7':
{
system( "cls" );
( a + b ).wyswietl();
break;
|
|
carlosmay |
» 2016-03-15 17:49:18 |
|
Garniturek Temat założony przez niniejszego użytkownika |
» 2016-03-15 17:54:41 Zedytowałem poprzedni post, proszę o pomo Wydaje mi się, że tak. A jakie masz zastrzeżenia? :) vec[ i ].size() = kolumny
|
|
michal11 |
» 2016-03-15 19:37:38 Źle ci się wydaje, nie można przypisywać do wartości zwracanej przez size(), miedzy innymi dlatego, że jest stała, poza tym to bardzo zła praktyka. Moim zdaniem to co ty chcesz zrobić to nie operator+ a operator+=, wtedy ma sens pisanie czegoś takiego cMatrix a;
cMatrix b;
a += b;
Przeciążanie operator powinno być jak najbardziej spójne z operatorami typów wbudowanych, jeżeli piszesz to nie oczekujesz, że nagle do a doda się b, tylko, że otrzymasz wynik który musisz do czegoś przypisać. Jeżeli chcesz zsumować 2 vectory to ja bym to tak zrobił: #include <iostream>
#include <vector>
#include <algorithm>
using Matrix = std::vector < std::vector < int >>;
void print( const Matrix & vec );
Matrix operator +( const Matrix & lhs, const Matrix & rhs );
void operator +=( Matrix & lhs, const Matrix & rhs );
int main()
{
Matrix vec1( 4, std::vector < int >( 4, 1 ) );
Matrix vec2( 4, std::vector < int >( 4, 2 ) );
std::cout << "vec1:" << std::endl;
print( vec1 );
std::cout << "vec1:" << std::endl;
print( vec2 );
std::cout << "vec1 + vec2:" << std::endl;
print( vec1 + vec2 );
std::cout << "vec1:" << std::endl;
print( vec1 );
std::cout << "vec1 po oper+=:" << std::endl;
vec1 += vec2;
print( vec1 );
return 0;
}
void print( const Matrix & vec )
{
for_each( vec.begin(), vec.end(),[]( const std::vector < int >& internal )
{
for_each( internal.begin(), internal.end(),[]( int val ) { std::cout << val << " "; } );
std::cout << std::endl;
} );
}
Matrix operator +( const Matrix & lhs, const Matrix & rhs )
{
Matrix ret( std::max( lhs.size(), rhs.size() ), std::vector < int >( std::max( lhs[ 0 ].size(), rhs[ 0 ].size() ), 0 ) );
for( size_t i = 0; i < ret.size(); ++i )
{
for( size_t j = 0; j < ret[ i ].size(); ++j )
{
ret[ i ][ j ] = lhs[ i ][ j ] + rhs[ i ][ j ];
}
}
return ret;
}
void operator +=( Matrix & lhs, const Matrix & rhs )
{
lhs = lhs + rhs;
}
pominąłem tylko sprawdzanie błędów, rozmiarów macierzy itp. rzeczy które trzeba zrobić żeby program się nie wysypywał gdy będą nieprawidłowe dane. |
|
| « 1 » 2 |